(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
window.Buffer = require("buffer").Buffer;
window.demofile = require("../dist/demo");

},{"../dist/demo":6,"buffer":81}],2:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function assertExists(value, message) {
    if (value == null)
        throw new Error(message || "expected non-null value");
    return value;
}
exports.default = assertExists;

},{}],3:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SND_STOP = exports.INVALID_NETWORKED_EHANDLE_VALUE = exports.MAX_USERDATA_BITS = exports.SUBSTRING_BITS = exports.MAX_CUSTOM_FILES = exports.SIGNED_GUID_LEN = exports.MAX_PLAYER_NAME_LENGTH = exports.MAX_SPLITSCREEN_CLIENTS = exports.MAX_OSPATH = exports.NUM_NETWORKED_EHANDLE_BITS = exports.NUM_NETWORKED_EHANDLE_SERIAL_NUMBER_BITS = exports.NETWORKED_EHANDLE_ENT_ENTRY_MASK = exports.MAX_EDICTS = exports.MAX_EDICT_BITS = void 0;
exports.MAX_EDICT_BITS = 11;
exports.MAX_EDICTS = 1 << exports.MAX_EDICT_BITS;
exports.NETWORKED_EHANDLE_ENT_ENTRY_MASK = exports.MAX_EDICTS - 1;
exports.NUM_NETWORKED_EHANDLE_SERIAL_NUMBER_BITS = 10;
exports.NUM_NETWORKED_EHANDLE_BITS = exports.MAX_EDICT_BITS + exports.NUM_NETWORKED_EHANDLE_SERIAL_NUMBER_BITS;
exports.MAX_OSPATH = 260;
exports.MAX_SPLITSCREEN_CLIENTS = 260;
exports.MAX_PLAYER_NAME_LENGTH = 128;
exports.SIGNED_GUID_LEN = 32;
exports.MAX_CUSTOM_FILES = 4;
exports.SUBSTRING_BITS = 5;
exports.MAX_USERDATA_BITS = 14;
exports.INVALID_NETWORKED_EHANDLE_VALUE = (1 << exports.NUM_NETWORKED_EHANDLE_BITS) - 1;
exports.SND_STOP = 1 << 2;

},{}],4:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ConVars = void 0;
const events_1 = require("events");
/**
 * Manages console variables.
 */
class ConVars extends events_1.EventEmitter {
    constructor() {
        super(...arguments);
        this.vars = new Map();
    }
    listen(demo) {
        demo.on("net_SetConVar", (msg) => {
            const convars = msg.convars;
            if (!convars)
                return;
            for (const cvar of convars.cvars) {
                const oldValue = this.vars.get(cvar.name);
                this.vars.set(cvar.name, cvar.value);
                const args = {
                    name: cvar.name,
                    value: cvar.value,
                    oldValue
                };
                this.emit(cvar.name, args);
                this.emit("change", args);
            }
        });
    }
}
exports.ConVars = ConVars;

},{"events":84}],5:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.decodeCrosshairCode = exports.CrosshairStyle = void 0;
const sharecode_1 = require("./sharecode");
var CrosshairStyle;
(function (CrosshairStyle) {
    CrosshairStyle[CrosshairStyle["Default"] = 0] = "Default";
    CrosshairStyle[CrosshairStyle["DefaultStatic"] = 1] = "DefaultStatic";
    CrosshairStyle[CrosshairStyle["Classic"] = 2] = "Classic";
    CrosshairStyle[CrosshairStyle["ClassicDynamic"] = 3] = "ClassicDynamic";
    CrosshairStyle[CrosshairStyle["ClassicStatic"] = 4] = "ClassicStatic";
})(CrosshairStyle = exports.CrosshairStyle || (exports.CrosshairStyle = {}));
function decodeCrosshairCode(shareCode) {
    function signed(byte) {
        return byte > 127 ? -(~byte & 0xff) - 1 : byte;
    }
    const bytes = (0, sharecode_1.decodeShareCode)(shareCode);
    if (bytes[1] !== bytes.slice(2).reduce((x, y) => x + y) % 256) {
        throw new Error("invalid crosshair code");
    }
    return {
        outline: bytes[4] / 2,
        red: bytes[5],
        green: bytes[6],
        blue: bytes[7],
        alpha: bytes[8],
        splitDistance: bytes[9],
        innerSplitAlpha: (bytes[11] >> 4) / 10,
        hasOutline: !!(bytes[11] & 8),
        outerSplitAlpha: (bytes[12] & 0xf) / 10,
        splitSizeRatio: (bytes[12] >> 4) / 10,
        thickness: bytes[13] / 10,
        length: bytes[15] / 10,
        gap: signed(bytes[3]) / 10,
        hasCenterDot: !!((bytes[14] >> 4) & 1),
        hasAlpha: !!((bytes[14] >> 4) & 4),
        isTStyle: !!((bytes[14] >> 4) & 8),
        style: CrosshairStyle[(bytes[14] & 0xf) >> 1]
    };
}
exports.decodeCrosshairCode = decodeCrosshairCode;

},{"./sharecode":28}],6:[function(require,module,exports){
(function (Buffer){(function (){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DemoFile = exports.parseHeader = void 0;
const events_1 = require("events");
const timers = require("timers");
const url_1 = require("url");
const https = require("https");
const ByteBuffer = require("bytebuffer");
const bitbuffer_1 = require("./ext/bitbuffer");
const assert = require("assert");
const consts_1 = require("./consts");
const convars_1 = require("./convars");
const entities_1 = require("./entities");
const gameevents_1 = require("./gameevents");
const icekey_1 = require("./icekey");
const net = require("./net");
const stringtables_1 = require("./stringtables");
const usermessages_1 = require("./usermessages");
const assert_exists_1 = require("./assert-exists");
const grenadetrajectory_1 = require("./supplements/grenadetrajectory");
const molotovdetonate_1 = require("./supplements/molotovdetonate");
const itempurchase_1 = require("./supplements/itempurchase");
function httpGet(url) {
    return new Promise((resolve, reject) => {
        https
            .request(url, res => {
            const chunks = [];
            res.on("data", chunk => {
                chunks.push(chunk);
            });
            res.on("end", () => {
                if (res.statusCode == 200) {
                    resolve(Buffer.concat(chunks));
                }
                else {
                    reject(`request '${url}' failed: ${res.statusCode} (${res.statusMessage})`);
                }
            });
        })
            .end();
    });
}
function parseHeaderBytebuf(bytebuf) {
    return {
        magic: bytebuf.readString(8, ByteBuffer.METRICS_BYTES).split("\0", 2)[0],
        protocol: bytebuf.readInt32(),
        networkProtocol: bytebuf.readInt32(),
        serverName: bytebuf
            .readString(consts_1.MAX_OSPATH, ByteBuffer.METRICS_BYTES)
            .split("\0", 2)[0],
        clientName: bytebuf
            .readString(consts_1.MAX_OSPATH, ByteBuffer.METRICS_BYTES)
            .split("\0", 2)[0],
        mapName: bytebuf
            .readString(consts_1.MAX_OSPATH, ByteBuffer.METRICS_BYTES)
            .split("\0", 2)[0],
        gameDirectory: bytebuf
            .readString(consts_1.MAX_OSPATH, ByteBuffer.METRICS_BYTES)
            .split("\0", 2)[0],
        playbackTime: bytebuf.readFloat(),
        playbackTicks: bytebuf.readInt32(),
        playbackFrames: bytebuf.readInt32(),
        signonLength: bytebuf.readInt32()
    };
}
/**
 * Parses a demo file header from the buffer.
 * @param {ArrayBuffer} buffer - Buffer of the demo header
 * @returns {IDemoHeader} Header object
 */
function parseHeader(buffer) {
    const bytebuf = ByteBuffer.wrap(buffer, true);
    return parseHeaderBytebuf(bytebuf);
}
exports.parseHeader = parseHeader;
/**
 * Represents a demo file for parsing.
 */
class DemoFile extends events_1.EventEmitter {
    /**
     * Starts parsing buffer as a demo file.
     *
     * @fires DemoFile#tickstart
     * @fires DemoFile#tickend
     * @fires DemoFile#end
     *
     * @param {ArrayBuffer} buffer - Buffer pointing to start of demo header
     */
    constructor() {
        super();
        /**
         * When parsing, set to current tick.
         */
        this.currentTick = -1;
        /**
         * Number of seconds per tick
         */
        this.tickInterval = NaN;
        /**
         * When parsing, set to the splitscreen slot for the current command.
         * @deprecated Splitscreen slot is unused for PC games.
         */
        this.playerSlot = 0;
        /**
         * Set to the client slot of the recording player.
         * Always null for GOTV demos.
         */
        this.recordingClientSlot = null;
        this._chunks = [];
        this._lastThreadYieldTime = 0;
        this._immediateTimerToken = null;
        this._timeoutTimerToken = null;
        this._encryptionKey = null;
        this._hasEnded = false;
        this._isBroadcastFragment = false;
        this._supplementEvents = [
            grenadetrajectory_1.default,
            molotovdetonate_1.default,
            itempurchase_1.default
        ];
        this._supplementCleanupFns = new Map();
        this.entities = new entities_1.Entities();
        this.gameEvents = new gameevents_1.GameEvents();
        this.stringTables = new stringtables_1.StringTables();
        this.userMessages = new usermessages_1.UserMessages();
        this.conVars = new convars_1.ConVars();
        this.gameEvents.listen(this);
        // It is important that entities listens after game events, as they both listen on
        // tickend.
        this.entities.listen(this);
        this.stringTables.listen(this);
        this.userMessages.listen(this);
        this.conVars.listen(this);
        // #65: Some demos are missing playbackTicks from the header
        // Pull the tick interval from ServerInfo
        this.on("svc_ServerInfo", msg => {
            this.tickInterval = msg.tickInterval;
        });
        this.on("svc_EncryptedData", msg => {
            if (!this._handleEncryptedData(msg)) {
                // Some demos appear to have the encryption key recorded
                // incorrectly in the .dem.info file. Don't throw an error
                // if we can't decode it correctly.
                // The game client silently skips bad encrypted messages.
                // See https://github.com/saul/demofile/issues/322#issuecomment-1085776379
                this.emit("warning", { message: "Unable to read encrypted message" });
            }
        });
        this.on("newListener", (event) => {
            // If we already have listeners for this event, nothing to do
            if (this.listenerCount(event) > 0)
                return;
            const supplement = this._findSupplement(event);
            if (supplement == null)
                return;
            const cleanupFn = supplement.setup(this);
            this._supplementCleanupFns.set(supplement, cleanupFn);
        });
        this.on("removeListener", (event) => {
            // If there are still listeners for this event, early out
            if (this.listenerCount(event) > 0)
                return;
            const supplement = this._findSupplement(event);
            if (supplement == null)
                return;
            // Don't cleanup if there are listeners on other emits that this supplement emits
            const existingListenerCount = supplement.emits.reduce((prev, name) => prev + this.listenerCount(name), 0);
            if (existingListenerCount > 0)
                return;
            const cleanupFn = (0, assert_exists_1.default)(this._supplementCleanupFns.get(supplement));
            cleanupFn();
            this._supplementCleanupFns.delete(supplement);
        });
    }
    /**
     * @returns Number of ticks per second
     */
    get tickRate() {
        return 1.0 / this.tickInterval;
    }
    /**
     * @returns Number of seconds elapsed
     */
    get currentTime() {
        return this.currentTick * this.tickInterval;
    }
    /**
     * Shortcut for `this.entities.players`
     * @returns All connected player entities
     */
    get players() {
        return this.entities.players;
    }
    /**
     * Shortcut for `this.entities.teams`
     * @returns All team entities
     */
    get teams() {
        return this.entities.teams;
    }
    /**
     * Shortcut for `this.entities.gameRules`
     * @returns GameRules entity
     */
    get gameRules() {
        return this.entities.gameRules;
    }
    _findSupplement(eventName) {
        for (const supplement of this._supplementEvents) {
            if (supplement.emits.indexOf(eventName) >= 0)
                return supplement;
        }
        return null;
    }
    /**
     * Start streaming a GOTV broadcast over HTTP.
     * Will keep streaming until the broadcast finishes.
     *
     * @param url URL to the GOTV broadcast.
     * @returns Promise that resolves then the broadcast finishes.
     */
    async parseBroadcast(url) {
        if (!url.endsWith("/"))
            url += "/";
        // Some packets are formatted slightly differently in
        // broadcast fragments compared to a normal demo file.
        this._isBroadcastFragment = true;
        const syncUrl = new url_1.URL("sync", url).toString();
        const syncResponse = await httpGet(syncUrl);
        const syncDto = JSON.parse(syncResponse.toString());
        if (syncDto.protocol !== 4) {
            throw new Error(`expected protocol version 4, got: ${syncDto.protocol}`);
        }
        if (syncDto.token_redirect != null) {
            url = new url_1.URL(syncDto.token_redirect, url).toString();
            if (!url.endsWith("/"))
                url += "/";
        }
        this.header = {
            magic: "HL2DEMO",
            protocol: syncDto.protocol,
            networkProtocol: 0,
            serverName: `GOTV Broadcast: ${url}`,
            clientName: "GOTV Demo",
            mapName: syncDto.map,
            gameDirectory: "csgo",
            playbackTime: 0,
            playbackTicks: 0,
            playbackFrames: 0,
            signonLength: 0
        };
        this.tickInterval = 1 / syncDto.tps;
        let cancelled = false;
        this.emit("start", {
            cancel() {
                cancelled = true;
            }
        });
        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
        if (cancelled) {
            return;
        }
        const startUrl = new url_1.URL(`${syncDto.signup_fragment | 0}/start`, url).toString();
        const startResponse = await httpGet(startUrl);
        // Read the signon fragment
        this._bytebuf = ByteBuffer.wrap(startResponse, true);
        while (this._bytebuf.remaining() > 0) {
            this._readCommand();
        }
        // Keep reading fragments until we run out
        let fragment = syncDto.fragment | 0;
        let fragmentType = "full";
        while (!this._hasEnded) {
            const fragmentUrl = new url_1.URL(`${fragment}/${fragmentType}`, url).toString();
            let fragmentResponse;
            try {
                fragmentResponse = await httpGet(fragmentUrl);
            }
            catch {
                // HTTP 404 errors are expected - each fragment only lasts for a few seconds.
                // Wait for 1-2 secs before retrying to avoid spamming the relay.
                await new Promise(resolve => setTimeout(resolve, 1000 + Math.random() * 1000));
                continue;
            }
            // We need to request {fragment}/full + {fragment}/delta
            if (fragmentType == "full") {
                fragmentType = "delta";
            }
            else {
                fragment += 1;
            }
            this._bytebuf = ByteBuffer.wrap(fragmentResponse, true);
            while (this._bytebuf.remaining() > 0) {
                this._readCommand();
            }
        }
    }
    parseStream(stream) {
        this._hasEnded = false;
        const onReceiveChunk = (chunk) => {
            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
            if (this._bytebuf == null) {
                this._bytebuf = ByteBuffer.wrap(chunk, true);
            }
            else {
                this._chunks.push(chunk);
            }
        };
        const readPacketChunk = () => {
            try {
                // Keep reading until we can't read any more
                while (this._bytebuf.remaining() > 0 || this._chunks.length > 0) {
                    this._bytebuf.mark();
                    this._readCommand();
                }
            }
            catch (e) {
                if (e instanceof RangeError) {
                    // Reset the byte buffer to the start of the last command
                    this._bytebuf.offset = Math.max(0, this._bytebuf.markedOffset);
                }
                else {
                    stream.off("data", onReceiveChunk);
                    const error = e instanceof Error
                        ? e
                        : new Error(`Exception during parsing: ${e}`);
                    this._emitEnd({ error, incomplete: false });
                }
            }
        };
        const readHeaderChunk = () => {
            // Wait for enough bytes for us to read the header
            if (!this._tryEnsureRemaining(1072))
                return;
            // Once we've read the header, remove this handler
            stream.off("data", readHeaderChunk);
            const cancelled = this._parseHeader();
            if (!cancelled)
                stream.on("data", readPacketChunk);
        };
        stream.on("data", onReceiveChunk);
        stream.on("data", readHeaderChunk);
        stream.on("error", e => {
            stream.off("data", onReceiveChunk);
            this._emitEnd({ error: e, incomplete: false });
        });
        stream.on("end", () => {
            var _a;
            const fullyConsumed = 
            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
            ((_a = this._bytebuf) === null || _a === void 0 ? void 0 : _a.remaining()) === 0 && this._chunks.length === 0;
            if (fullyConsumed)
                return;
            this._emitEnd({ incomplete: true });
        });
    }
    parse(buffer) {
        this._hasEnded = false;
        this._bytebuf = ByteBuffer.wrap(buffer, true);
        const cancelled = this._parseHeader();
        if (!cancelled)
            timers.setTimeout(this._parseRecurse.bind(this), 0);
    }
    /**
     * Cancel the current parse operation.
     */
    cancel() {
        if (this._immediateTimerToken) {
            timers.clearImmediate(this._immediateTimerToken);
            this._immediateTimerToken = null;
        }
        if (this._timeoutTimerToken) {
            timers.clearTimeout(this._timeoutTimerToken);
            this._timeoutTimerToken = null;
        }
    }
    /**
     * Set encryption key for decrypting `svc_EncryptedData` packets.
     * This allows decryption of messages from public matchmaking, like
     * chat messages and caster voice data.
     *
     * The key can be extracted from `match730_*.dem.info` files with `extractPublicEncryptionKey`.
     *
     * @param publicKey Public encryption key.
     */
    setEncryptionKey(publicKey) {
        if (publicKey != null && publicKey.length !== 16) {
            throw new Error(`Public key must be 16 bytes long, got ${publicKey.length} bytes instead`);
        }
        this._encryptionKey = publicKey;
    }
    _emitEnd(e) {
        if (this._hasEnded)
            return;
        if (e.error) {
            this.emit("error", e.error);
        }
        this.emit("end", e);
        this._hasEnded = true;
    }
    _parseHeader() {
        this.header = parseHeaderBytebuf(this._bytebuf);
        // #65: Some demos are missing playbackTicks from the header
        if (this.header.playbackTicks > 0) {
            this.tickInterval = this.header.playbackTime / this.header.playbackTicks;
        }
        // If this is a POV demo, try to figure out who the recording player is
        if (this.header.clientName !== "GOTV Demo") {
            this.stringTables.on("update", this._handleStringTableUpdate.bind(this));
        }
        let cancelled = false;
        this.emit("start", {
            cancel: () => {
                cancelled = true;
            }
        });
        return cancelled;
    }
    _readIBytes() {
        this._ensureRemaining(4);
        const length = this._bytebuf.readInt32();
        this._ensureRemaining(length);
        return this._bytebuf.readBytes(length);
    }
    _handleEncryptedData(msg) {
        if (msg.keyType !== 2 || this._encryptionKey == null)
            return true;
        const key = new icekey_1.IceKey(2);
        key.set(this._encryptionKey);
        assert(msg.encrypted.length % key.blockSize() === 0);
        const plainText = new Uint8Array(msg.encrypted.length);
        key.decryptUint8Array(msg.encrypted, plainText);
        // Create a ByteBuffer skipped past the padding
        const buf = ByteBuffer.wrap(plainText, true);
        const paddingBytes = buf.readUint8();
        if (paddingBytes + 4 > buf.remaining())
            return false;
        buf.skip(paddingBytes);
        // For some reason, the size is encoded as an int32, then as a varint32
        buf.BE();
        const bytesWritten = buf.readInt32();
        buf.LE();
        if (buf.remaining() !== bytesWritten)
            return false;
        const cmd = buf.readVarint32();
        const size = buf.readVarint32();
        if (buf.remaining() !== size)
            return false;
        const message = net.findByType(cmd);
        assert(message != null, `No message handler for ${cmd}`);
        if (this.listenerCount(message.name)) {
            const msgInst = message.class.decode(new Uint8Array(buf.toBuffer()));
            this.emit(message.name, msgInst);
        }
        return true;
    }
    _handleStringTableUpdate(update) {
        if (this.recordingClientSlot != null)
            return;
        if (update.table.name === "userinfo" && update.userData != null) {
            const playerInfo = update.userData;
            if (playerInfo.name === this.header.clientName) {
                this.recordingClientSlot = update.entryIndex;
            }
        }
    }
    /**
     * Fired when a packet of this type is hit. `svc_MessageName` events are also fired.
     * @public
     * @event DemoFile#net_MessageName
     */
    _handleDemoPacket() {
        if (!this._isBroadcastFragment) {
            this._ensureRemaining(160);
            // skip cmd info
            this._bytebuf.skip(152);
            // skip over sequence info
            this._bytebuf.readInt32();
            this._bytebuf.readInt32();
        }
        const chunk = this._readIBytes();
        while (chunk.remaining()) {
            const cmd = chunk.readVarint32();
            const size = chunk.readVarint32();
            const message = net.findByType(cmd);
            assert(message != null, `No message handler for ${cmd}`);
            if (this.listenerCount(message.name)) {
                const messageBuffer = chunk.readBytes(size);
                const msgInst = message.class.decode(new Uint8Array(messageBuffer.toBuffer()));
                this.emit(message.name, msgInst);
            }
            else {
                chunk.skip(size);
            }
        }
    }
    _handleDataChunk() {
        this._readIBytes();
    }
    _handleDataTables() {
        const chunk = this._isBroadcastFragment
            ? this._bytebuf
            : this._readIBytes();
        this.entities.handleDataTables(chunk);
    }
    _handleUserCmd() {
        this._ensureRemaining(4);
        this._bytebuf.readInt32(); // outgoing sequence
        const chunk = this._readIBytes();
        // If nobody's listening, don't waste cycles decoding it
        if (!this.listenerCount("usercmd"))
            return;
        const bitbuf = bitbuffer_1.BitStream.from(chunk.buffer.slice(chunk.offset, chunk.limit));
        const move = {
            commandNumber: 0,
            tickCount: 0,
            viewAngles: { x: 0, y: 0, z: 0 },
            aimDirection: { x: 0, y: 0, z: 0 },
            forwardMove: 0,
            sideMove: 0,
            upMove: 0,
            buttons: new Array(),
            impulse: 0,
            weaponSelect: 0,
            weaponSubType: 0,
            randomSeed: 0,
            mouseDeltaX: 0,
            mouseDeltaY: 0
        };
        if (bitbuf.readOneBit()) {
            move.commandNumber = bitbuf.readUInt32();
        }
        else {
            move.commandNumber = 1;
        }
        if (bitbuf.readOneBit()) {
            move.tickCount = bitbuf.readUInt32();
        }
        else {
            move.tickCount = 1;
        }
        // Read direction
        if (bitbuf.readOneBit())
            move.viewAngles.x = bitbuf.readFloat32();
        if (bitbuf.readOneBit())
            move.viewAngles.y = bitbuf.readFloat32();
        if (bitbuf.readOneBit())
            move.viewAngles.z = bitbuf.readFloat32();
        // Read aim direction
        if (bitbuf.readOneBit())
            move.aimDirection.x = bitbuf.readFloat32();
        if (bitbuf.readOneBit())
            move.aimDirection.y = bitbuf.readFloat32();
        if (bitbuf.readOneBit())
            move.aimDirection.z = bitbuf.readFloat32();
        // Read movement
        if (bitbuf.readOneBit())
            move.forwardMove = bitbuf.readFloat32();
        if (bitbuf.readOneBit())
            move.sideMove = bitbuf.readFloat32();
        if (bitbuf.readOneBit())
            move.upMove = bitbuf.readFloat32();
        if (bitbuf.readOneBit()) {
            const buttons = bitbuf.readUInt32();
            if (buttons & (1 << 0))
                move.buttons.push("attack");
            if (buttons & (1 << 1))
                move.buttons.push("jump");
            if (buttons & (1 << 2))
                move.buttons.push("duck");
            if (buttons & (1 << 3))
                move.buttons.push("forward");
            if (buttons & (1 << 4))
                move.buttons.push("back");
            if (buttons & (1 << 5))
                move.buttons.push("use");
            if (buttons & (1 << 6))
                move.buttons.push("cancel");
            if (buttons & (1 << 7))
                move.buttons.push("left");
            if (buttons & (1 << 8))
                move.buttons.push("right");
            if (buttons & (1 << 9))
                move.buttons.push("moveleft");
            if (buttons & (1 << 10))
                move.buttons.push("moveright");
            if (buttons & (1 << 11))
                move.buttons.push("attack2");
            if (buttons & (1 << 12))
                move.buttons.push("run");
            if (buttons & (1 << 13))
                move.buttons.push("reload");
            if (buttons & (1 << 14))
                move.buttons.push("alt1");
            if (buttons & (1 << 15))
                move.buttons.push("alt2");
            if (buttons & (1 << 16))
                move.buttons.push("score");
            if (buttons & (1 << 17))
                move.buttons.push("speed");
            if (buttons & (1 << 18))
                move.buttons.push("walk");
            if (buttons & (1 << 19))
                move.buttons.push("zoom");
            if (buttons & (1 << 20))
                move.buttons.push("weapon1");
            if (buttons & (1 << 21))
                move.buttons.push("weapon2");
            if (buttons & (1 << 22))
                move.buttons.push("bullrush");
            if (buttons & (1 << 23))
                move.buttons.push("grenade1");
            if (buttons & (1 << 24))
                move.buttons.push("grenade2");
            if (buttons & (1 << 25))
                move.buttons.push("lookspin");
        }
        if (bitbuf.readOneBit())
            move.impulse = bitbuf.readUInt8();
        if (bitbuf.readOneBit()) {
            move.weaponSelect = bitbuf.readUBits(consts_1.MAX_EDICT_BITS);
            if (bitbuf.readOneBit())
                move.weaponSubType = bitbuf.readUBits(6);
        }
        if (bitbuf.readOneBit())
            move.mouseDeltaX = bitbuf.readInt16();
        if (bitbuf.readOneBit())
            move.mouseDeltaY = bitbuf.readInt16();
        this.emit("usercmd", move);
    }
    _handleStringTables() {
        const chunk = this._readIBytes();
        const bitbuf = bitbuffer_1.BitStream.from(chunk.buffer.slice(chunk.offset, chunk.limit));
        this.stringTables.handleStringTables(bitbuf);
    }
    _tryEnsureRemaining(bytes) {
        const remaining = this._bytebuf.remaining();
        if (remaining >= bytes)
            return true;
        let left = bytes - remaining;
        for (let i = 0; i < this._chunks.length && left > 0; ++i)
            left -= this._chunks[i].length;
        // We don't have enough bytes with what we have buffered up
        if (left > 0)
            return false;
        const mark = Math.max(0, this._bytebuf.markedOffset);
        const newOffset = this._bytebuf.offset - mark;
        // Reset to the marked offset. We're never going to need the bytes preceding it
        this._bytebuf.offset = mark;
        this._bytebuf = ByteBuffer.wrap(Buffer.concat([
            new Uint8Array(this._bytebuf.toBuffer()),
            ...this._chunks
        ]), true);
        this._chunks = [];
        // Advance to the point we'd already read up to
        this._bytebuf.offset = newOffset;
        return true;
    }
    _ensureRemaining(bytes) {
        if (!this._tryEnsureRemaining(bytes)) {
            throw new RangeError(`Not enough data to continue parsing. ${bytes} bytes needed`);
        }
    }
    _readCommand() {
        this._ensureRemaining(6);
        const command = this._bytebuf.readUint8();
        const tick = this._bytebuf.readInt32();
        this.playerSlot = this._bytebuf.readUint8();
        if (tick !== this.currentTick) {
            this.emit("tickend", this.currentTick);
            this.currentTick = tick;
            this.emit("tickstart", this.currentTick);
        }
        switch (command) {
            case 2 /* DemoCommands.Packet */:
            case 1 /* DemoCommands.Signon */:
                this._handleDemoPacket();
                break;
            case 6 /* DemoCommands.DataTables */:
                this._handleDataTables();
                break;
            case 9 /* DemoCommands.StringTables */:
                this._handleStringTables();
                break;
            case 4 /* DemoCommands.ConsoleCmd */: // TODO
                this._handleDataChunk();
                break;
            case 5 /* DemoCommands.UserCmd */:
                this._handleUserCmd();
                break;
            case 7 /* DemoCommands.Stop */:
                this.cancel();
                this.emit("tickend", this.currentTick);
                this._emitEnd({ incomplete: false });
                return;
            case 8 /* DemoCommands.CustomData */:
                throw new Error("Custom data not supported");
            case 3 /* DemoCommands.SyncTick */:
                break;
            default:
                throw new Error(`Unrecognised command: ${command}`);
        }
    }
    _parseRecurse() {
        const now = Date.now();
        // Schedule another round of parsing
        if (now - this._lastThreadYieldTime < 32) {
            this._immediateTimerToken = timers.setImmediate(this._parseRecurse.bind(this));
        }
        else {
            this._lastThreadYieldTime = now;
            this._timeoutTimerToken = timers.setTimeout(this._parseRecurse.bind(this), 0);
        }
        try {
            this.emit("progress", this._bytebuf.offset / this._bytebuf.limit);
            this._readCommand();
        }
        catch (e) {
            // Always cancel if we have an error - we've already scheduled the next tick
            this.cancel();
            // #11, #172: Some demos have been written incompletely.
            // Don't throw an error when we run out of bytes to read.
            if (e instanceof RangeError &&
                this.header.playbackTicks === 0 &&
                this.header.playbackTime === 0 &&
                this.header.playbackFrames === 0) {
                this._emitEnd({ incomplete: true });
            }
            else {
                const error = e instanceof Error ? e : new Error(`Exception during parsing: ${e}`);
                this._emitEnd({ error, incomplete: false });
            }
        }
    }
}
exports.DemoFile = DemoFile;

}).call(this)}).call(this,require("buffer").Buffer)

},{"./assert-exists":2,"./consts":3,"./convars":4,"./entities":7,"./ext/bitbuffer":18,"./gameevents":20,"./icekey":21,"./net":22,"./stringtables":29,"./supplements/grenadetrajectory":30,"./supplements/itempurchase":31,"./supplements/molotovdetonate":32,"./usermessages":33,"assert":73,"buffer":81,"bytebuffer":83,"events":84,"https":85,"timers":752,"url":753}],7:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Entities = void 0;
const assert = require("assert");
const events_1 = require("events");
const assert_exists_1 = require("./assert-exists");
const bitbuffer_1 = require("./ext/bitbuffer");
const consts = require("./consts");
const net = require("./net");
const immutable = require("immutable");
const iter_tools_1 = require("iter-tools");
const baseentity_1 = require("./entities/baseentity");
const gamerules_1 = require("./entities/gamerules");
const networkable_1 = require("./entities/networkable");
const player_1 = require("./entities/player");
const team_1 = require("./entities/team");
const weapon_1 = require("./entities/weapon");
const props_1 = require("./props");
const Long = require("long");
const projectile_1 = require("./entities/projectile");
function isPropExcluded(excludes, table, prop) {
    return excludes.find(excluded => table.netTableName === excluded.dtName &&
        prop.varName === excluded.varName);
}
function readFieldIndex(entityBitBuffer, lastIndex, newWay) {
    if (newWay && entityBitBuffer.readOneBit()) {
        return lastIndex + 1;
    }
    let ret = 0;
    if (newWay && entityBitBuffer.readOneBit()) {
        ret = entityBitBuffer.readUBits(3);
    }
    else {
        ret = entityBitBuffer.readUBits(7);
        switch (ret & (32 | 64)) {
            case 32:
                ret = (ret & ~96) | (entityBitBuffer.readUBits(2) << 5);
                assert(ret >= 32);
                break;
            case 64:
                ret = (ret & ~96) | (entityBitBuffer.readUBits(4) << 5);
                assert(ret >= 128);
                break;
            case 96:
                ret = (ret & ~96) | (entityBitBuffer.readUBits(7) << 5);
                assert(ret >= 512);
                break;
        }
    }
    if (ret === 0xfff) {
        // end marker is 4095 for CS:GO
        return -1;
    }
    return lastIndex + 1 + ret;
}
function cloneProps(props) {
    const result = {};
    // eslint-disable-next-line no-restricted-syntax
    for (const tableName in props) {
        const oldTable = props[tableName];
        const newTable = {};
        // eslint-disable-next-line no-restricted-syntax
        for (const prop in oldTable) {
            newTable[prop] = oldTable[prop];
        }
        result[tableName] = newTable;
    }
    return result;
}
/**
 * Represents entities and networked properties within a demo.
 */
class Entities extends events_1.EventEmitter {
    constructor() {
        super(...arguments);
        this.dataTables = [];
        this.serverClasses = [];
        /**
         * Map of entity index => networkable instance
         */
        this.entities = new Map();
        this.markedForDeletion = [];
        this.staticBaselines = {};
        this.pendingBaselines = {};
        this.serverClassBits = 0;
        this.tableClassMap = {
            DT_CSPlayer: player_1.Player,
            DT_Team: team_1.Team,
            DT_CSGameRules: gamerules_1.GameRules,
            DT_BaseCSGrenadeProjectile: projectile_1.Projectile,
            DT_WeaponCSBase: weapon_1.Weapon,
            DT_BaseEntity: baseentity_1.BaseEntity
        };
        this._serverClassConstructor = new Map();
        /**
         * Set of which entities were active in the most recent tick.
         */
        this.transmitEntities = null;
        this._entityBaselines = [
            new Map(),
            new Map()
        ];
        this._frames = immutable.Map();
        this._demo = null;
        this._singletonEnts = {};
        this._currentServerTick = -1;
        this._maxPlayers = 0;
        this._userInfoTable = null;
        this._userIdToEntity = new Map();
        this._steam64IdToEntity = new Map();
        this._accountNumberToEntity = new Map();
    }
    get playerResource() {
        return this._demo.entities.getSingleton("CCSPlayerResource");
    }
    get gameRules() {
        return this.getSingleton("CCSGameRulesProxy");
    }
    get teams() {
        return Array.from(this.findAllWithClass(team_1.Team));
    }
    get players() {
        const players = [];
        for (let i = 1; i <= this._maxPlayers; ++i) {
            const entity = this.entities.get(i);
            // Only return players that are fully connected
            if ((entity === null || entity === void 0 ? void 0 : entity.userInfo) != null) {
                players.push(entity);
            }
        }
        return players;
    }
    get weapons() {
        return Array.from(this.findAllWithClass(weapon_1.Weapon));
    }
    listen(demo) {
        this._demo = demo;
        demo.on("svc_PacketEntities", e => this._handlePacketEntities(e));
        demo.on("svc_TempEntities", e => this._handleTempEntities(e));
        demo.on("svc_ServerInfo", e => {
            this._maxPlayers = e.maxClients;
        });
        demo.on("net_Tick", e => {
            this._currentServerTick = e.tick;
        });
        demo.stringTables.on("create", table => {
            if (table.name === "userinfo")
                this._userInfoTable = table;
        });
        demo.stringTables.on("update", e => this._handleStringTableUpdate(e));
        demo.on("tickend", () => {
            if (this.markedForDeletion.length > 0) {
                for (const index of this.markedForDeletion) {
                    this.entities.delete(index);
                    this.emit("remove", { index });
                }
                this.markedForDeletion.length = 0;
            }
        });
    }
    /**
     * Determines whether handle is set.
     * This function does not determine whether the handle points to a valid entity.
     * @param {number} handle - Networked entity handle value
     * @returns {boolean} true if handle is set
     */
    isHandleSet(handle) {
        return handle !== consts.INVALID_NETWORKED_EHANDLE_VALUE;
    }
    /**
     * Returns the entity specified by a particular handle.
     * @param {number} handle - Networked entity handle value
     * @returns {Entity|null} Entity referenced by the handle. `null` if no matching entity.
     */
    getByHandle(handle) {
        if (!handle.isValid) {
            return null;
        }
        const ent = this.entities.get(handle.index);
        if (ent == null || ent.serialNum !== handle.serialNum) {
            return null;
        }
        return ent;
    }
    /**
     * Returns the entity that belongs to the player with a given user ID.
     * @param {number} userId - Player user ID
     * @returns {Player|null} Entity referenced by the user ID. `null` if no matching player.
     */
    getByUserId(userId) {
        const entityIndex = this._userIdToEntity.get(userId);
        if (entityIndex === undefined)
            return null;
        return this.entities.get(entityIndex);
    }
    /**
     * Returns the entity that belongs to the player with a given Steam account ID.
     * @param {number} accountId - Steam account ID
     * @returns {Player|null} Entity referenced by the account ID. `null` if no matching player.
     */
    getByAccountId(accountId) {
        const entityIndex = this._accountNumberToEntity.get(accountId);
        if (entityIndex === undefined)
            return null;
        return this.entities.get(entityIndex);
    }
    /**
     * Returns the entity that belongs to the player with a given 64-bit Steam ID.
     * @param {Long|string} steam64Id - 64-bit Steam ID
     * @returns {Player|null} Entity referenced by the Steam ID. `null` if no matching player.
     */
    getBySteam64Id(steam64Id) {
        const idString = steam64Id instanceof Long ? steam64Id.toString() : steam64Id;
        const entityIndex = this._steam64IdToEntity.get(idString);
        if (entityIndex === undefined)
            return null;
        return this.entities.get(entityIndex);
    }
    getSingleton(serverClass) {
        const existing = this._singletonEnts[serverClass];
        if (existing) {
            return existing;
        }
        const result = (0, iter_tools_1.find)(([, ent]) => ent.serverClass.name === serverClass, this.entities);
        if (!result) {
            throw new Error(`Missing singleton ${serverClass}`);
        }
        const [, entity] = result;
        this._singletonEnts[serverClass] = entity;
        return entity;
    }
    *findAllWithTable(table) {
        for (const ent of this.entities.values()) {
            if (table in ent.props) {
                yield ent;
            }
        }
    }
    *findAllWithClass(klass) {
        for (const ent of this.entities.values()) {
            if (ent instanceof klass) {
                yield ent;
            }
        }
    }
    handleDataTables(chunk) {
        // eslint-disable-next-line no-constant-condition
        while (true) {
            const descriptor = net.findByType(chunk.readVarint32());
            assert((descriptor === null || descriptor === void 0 ? void 0 : descriptor.name) === "svc_SendTable", "expected SendTable message");
            const length = chunk.readVarint32();
            const msg = descriptor.class.decode(new Uint8Array(chunk.readBytes(length).toBuffer()));
            if (msg.isEnd) {
                break;
            }
            this.dataTables.push(msg);
        }
        const serverClasses = chunk.readShort();
        this.serverClassBits = Math.ceil(Math.log2(serverClasses));
        for (let i = 0; i < serverClasses; ++i) {
            const classId = chunk.readShort();
            assert(classId === i, "server class entry for invalid class ID");
            const name = chunk.readCString();
            const dtName = chunk.readCString();
            const dataTable = (0, assert_exists_1.default)(this._findTableByName(dtName), "no data table for server class");
            const serverClass = {
                name,
                dtName,
                dataTable,
                flattenedProps: this._flattenDataTable(dataTable)
            };
            this.serverClasses.push(serverClass);
            // Find the constructor for this server class
            const tablesInClass = new Set(serverClass.flattenedProps.map(prop => prop.table.netTableName));
            // eslint-disable-next-line no-restricted-syntax
            for (const tableName in this.tableClassMap) {
                if (tablesInClass.has(tableName)) {
                    this._serverClassConstructor.set(classId, this.tableClassMap[tableName]);
                    break;
                }
            }
            // parse any pending baseline
            const pendingBaseline = this.pendingBaselines[classId];
            if (pendingBaseline) {
                this.staticBaselines[classId] = this._parseInstanceBaseline(pendingBaseline, classId);
                this.emit("baselineupdate", {
                    classId,
                    serverClass,
                    baseline: this.staticBaselines[classId]
                });
                delete this.pendingBaselines[classId];
            }
        }
        this.emit("datatablesready");
    }
    _gatherExcludes(table) {
        const excludes = [];
        for (const prop of table.props) {
            if ((prop.flags & props_1.SPROP_EXCLUDE) !== 0) {
                excludes.push(prop);
            }
            if (prop.type === 6 /* PropType.DataTable */) {
                const subTable = (0, assert_exists_1.default)(this._findTableByName(prop.dtName));
                excludes.push(...this._gatherExcludes(subTable));
            }
        }
        return excludes;
    }
    _gatherProps(table, excludes) {
        const flattened = [];
        for (let index = 0; index < table.props.length; ++index) {
            const prop = table.props[index];
            if ((prop.flags & props_1.SPROP_INSIDEARRAY) !== 0 ||
                (prop.flags & props_1.SPROP_EXCLUDE) !== 0 ||
                isPropExcluded(excludes, table, prop)) {
                continue;
            }
            if (prop.type === 6 /* PropType.DataTable */) {
                const subTable = (0, assert_exists_1.default)(this._findTableByName(prop.dtName));
                const childProps = this._gatherProps(subTable, excludes);
                if ((prop.flags & props_1.SPROP_COLLAPSIBLE) === 0) {
                    for (const fp of childProps) {
                        fp.collapsible = false;
                    }
                }
                flattened.push(...childProps);
            }
            else {
                flattened.push({
                    prop,
                    table,
                    decode: (0, props_1.makeDecoder)(prop, prop.type === 5 /* PropType.Array */ ? table.props[index - 1] : undefined),
                    collapsible: true
                });
            }
        }
        // collapsible props should come after non-collapsible
        return flattened.sort(({ collapsible: a }, { collapsible: b }) => (a ? 1 : 0) - (b ? 1 : 0));
    }
    _flattenDataTable(table) {
        const flattenedProps = this._gatherProps(table, this._gatherExcludes(table));
        const prioritySet = new Set(flattenedProps.map(fp => fp.prop.priority));
        prioritySet.add(64);
        const priorities = Array.from(prioritySet).sort((a, b) => a - b);
        let start = 0;
        // On this surface this looks like a sort by priority (or min(64, priority)
        // for CHANGES_OFTEN props). It's not a stable sort so it can't just be
        // replaced with JS Array#sort
        for (const priority of priorities) {
            // eslint-disable-next-line no-constant-condition
            while (true) {
                let currentProp;
                for (currentProp = start; currentProp < flattenedProps.length; ++currentProp) {
                    const prop = flattenedProps[currentProp].prop;
                    if (prop.priority === priority ||
                        (priority === 64 && (prop.flags & props_1.SPROP_CHANGES_OFTEN) !== 0)) {
                        if (start !== currentProp) {
                            const temp = flattenedProps[start];
                            flattenedProps[start] = flattenedProps[currentProp];
                            flattenedProps[currentProp] = temp;
                        }
                        start++;
                        break;
                    }
                }
                if (currentProp === flattenedProps.length) {
                    break;
                }
            }
        }
        return flattenedProps;
    }
    _findTableByName(name) {
        return this.dataTables.find(table => table.netTableName === name);
    }
    _addEntity(index, classId, serialNum, existingEntity, entityBaseline) {
        const baseline = entityBaseline || this.staticBaselines[classId];
        if (!baseline) {
            throw new Error(`no baseline for entity ${index} (class ID ${classId})`);
        }
        const props = cloneProps(baseline);
        // If we already have this entity, start fresh with baseline props
        if ((existingEntity === null || existingEntity === void 0 ? void 0 : existingEntity.serialNum) === serialNum) {
            existingEntity.props = props;
            return existingEntity;
        }
        // Delete the entity if the serial numbers mismatch
        if (existingEntity) {
            this._removeEntity(index, true);
        }
        const klass = this._serverClassConstructor.get(classId) || networkable_1.Networkable;
        const entity = new klass(this._demo, index, classId, serialNum, props);
        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
        this.entities.set(index, entity);
        return entity;
    }
    _removeEntity(index, immediate) {
        const entity = this.entities.get(index);
        if (!entity) {
            return;
        }
        // It's possible that the entity is already marked for deletion.
        // This is because entities are deleted at the end of the dem_packet,
        // after the game events fire.
        if (!immediate && entity.deleting) {
            return;
        }
        this.emit("beforeremove", { entity, immediate });
        if (immediate) {
            this.entities.delete(index);
            this.emit("remove", { index });
        }
        else {
            entity.deleting = true;
            this.markedForDeletion.push(index);
        }
    }
    _parseEntityUpdate(entityBitBuffer, classId) {
        const serverClass = this.serverClasses[classId];
        const newWay = entityBitBuffer.readOneBit();
        let lastIndex = -1;
        const fieldIndices = [];
        // eslint-disable-next-line no-constant-condition
        while (true) {
            lastIndex = readFieldIndex(entityBitBuffer, lastIndex, newWay);
            if (lastIndex === -1) {
                break;
            }
            fieldIndices.push(lastIndex);
        }
        const updatedProps = new Array(fieldIndices.length);
        for (let i = 0; i < fieldIndices.length; ++i) {
            const propIndex = fieldIndices[i];
            const flattenedProp = serverClass.flattenedProps[propIndex];
            assert(flattenedProp);
            updatedProps[i] = {
                prop: flattenedProp,
                value: flattenedProp.decode(entityBitBuffer)
            };
        }
        return updatedProps;
    }
    _readNewEntity(entityBitBuffer, entity) {
        const updates = this._parseEntityUpdate(entityBitBuffer, entity.classId);
        const recordChanges = this.listenerCount("change") > 0;
        const changes = recordChanges
            ? new Array(updates.length)
            : [];
        for (let i = 0; i < updates.length; ++i) {
            const update = updates[i];
            const tableName = update.prop.table.netTableName;
            const varName = update.prop.prop.varName;
            const table = entity.props[tableName];
            const oldValue = table && varName in table ? table[varName] : undefined;
            entity.updateProp(tableName, varName, update.value);
            if (recordChanges) {
                changes[i] = {
                    tableName,
                    varName,
                    oldValue,
                    newValue: update.value
                };
            }
        }
        if (recordChanges) {
            this.emit("change", {
                entity,
                changes
            });
        }
    }
    _updatesToPropObject(target, updates) {
        for (const update of updates) {
            const tableName = update.prop.table.netTableName;
            const varName = update.prop.prop.varName;
            target[tableName] = Object.assign(target[tableName] || {}, {
                [varName]: update.value
            });
        }
        return target;
    }
    _handleTempEntities(msg) {
        const entityBitBuffer = bitbuffer_1.BitStream.from(msg.entityData);
        let lastClassId = -1;
        let lastProps = null;
        // Reliable tempents are sent with 0 entries, but really they have 1
        const numEntries = msg.numEntries === 0 ? 1 : msg.numEntries;
        for (let i = 0; i < numEntries; ++i) {
            let fireDelay = 0.0;
            if (entityBitBuffer.readOneBit()) {
                fireDelay = entityBitBuffer.readSBits(8) / 100.0;
            }
            if (entityBitBuffer.readOneBit()) {
                lastClassId = entityBitBuffer.readUBits(this.serverClassBits) - 1;
                const updates = this._parseEntityUpdate(entityBitBuffer, lastClassId);
                lastProps = this._updatesToPropObject({}, updates);
            }
            else {
                // delta against last temp entity
                assert(lastClassId !== -1, "Delta with no baseline");
                const updates = this._parseEntityUpdate(entityBitBuffer, lastClassId);
                lastProps = this._updatesToPropObject(cloneProps((0, assert_exists_1.default)(lastProps)), updates);
            }
            this.emit("tempent", {
                delay: fireDelay,
                classId: lastClassId,
                serverClass: this.serverClasses[lastClassId],
                props: lastProps
            });
        }
    }
    _handlePacketEntities(msg) {
        // Take a copy of the transmitted entities from the delta frame
        // Otherwise start with a blank slate
        const baseTransmitEntities = (0, assert_exists_1.default)(msg.isDelta
            ? this._frames.get(msg.deltaFrom)
            : immutable.Set(), `delta from unknown frame ${msg.deltaFrom}`);
        if (!msg.isDelta) {
            // Clear out old entities - this is a full update
            for (const entityIndex of Array.from(this.entities.keys())) {
                this._removeEntity(entityIndex, true);
            }
            // Remove all frames - we won't be using them
            this._frames = immutable.Map();
            // Clear all entity baselines
            for (const baseline of this._entityBaselines) {
                baseline.clear();
            }
        }
        const newFrame = baseTransmitEntities.withMutations(mutableFrame => this._readPacketEntities(msg, mutableFrame));
        this._frames = this._frames.set(this._currentServerTick, newFrame);
        this.transmitEntities = newFrame;
        // Delete old frames that we no longer need to reference
        if (msg.isDelta) {
            const oldFrames = (0, iter_tools_1.filter)(tick => tick < msg.deltaFrom, this._frames.keys());
            this._frames = this._frames.removeAll(oldFrames);
        }
    }
    _readPacketEntities(msg, frame) {
        const entityBitBuffer = bitbuffer_1.BitStream.from(msg.entityData);
        let entityIndex = -1;
        for (let i = 0; i < msg.updatedEntries; ++i) {
            entityIndex += 1 + entityBitBuffer.readUBitVar();
            assert(entityIndex < consts.MAX_EDICTS, "newEntity >= MAX_EDICTS");
            if (entityBitBuffer.readOneBit()) {
                assert(msg.isDelta, "entity leaving PVS on full update");
                frame.remove(entityIndex);
                if (entityBitBuffer.readOneBit()) {
                    // 0b11: FHDR_LEAVEPVS | FHDR_DELETE
                    this._removeEntity(entityIndex, false);
                }
                else {
                    // 0b10: FHDR_LEAVEPVS
                }
                // eslint-disable-next-line no-dupe-else-if
            }
            else if (entityBitBuffer.readOneBit()) {
                // 0b01: FHDR_ENTERPVS
                frame.add(entityIndex);
                const classId = entityBitBuffer.readUBits(this.serverClassBits);
                const serialNum = entityBitBuffer.readUBits(consts.NUM_NETWORKED_EHANDLE_SERIAL_NUMBER_BITS);
                const existingBaseline = this._entityBaselines[msg.baseline].get(entityIndex);
                const entityBaselineProps = msg.isDelta && (existingBaseline === null || existingBaseline === void 0 ? void 0 : existingBaseline.classId) === classId
                    ? existingBaseline.props
                    : undefined;
                const existingEntity = this.entities.get(entityIndex);
                const entity = this._addEntity(entityIndex, classId, serialNum, existingEntity, entityBaselineProps);
                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                this._readNewEntity(entityBitBuffer, entity);
                if (entity !== existingEntity) {
                    const eventVars = { entity };
                    this.emit("create", eventVars);
                    // Still emit 'postcreate' for backwards compatibility
                    this.emit("postcreate", eventVars);
                }
                // Update the OTHER baseline with the merged result of `old baseline + new props`
                if (msg.updateBaseline) {
                    this._entityBaselines[msg.baseline ? 0 : 1].set(entityIndex, {
                        classId,
                        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
                        props: cloneProps(entity.props)
                    });
                }
            }
            else {
                // 0b00: DeltaEnt
                const entity = (0, assert_exists_1.default)(this.entities.get(entityIndex), `missing client entity ${entityIndex}`);
                assert(frame.contains(entityIndex), `delta on dormant entity ${entityIndex}`);
                this._readNewEntity(entityBitBuffer, entity);
            }
        }
        // Read deletions
        if (msg.isDelta) {
            entityIndex = -1;
            const deletions = entityBitBuffer.readUBitVar();
            for (let i = 0; i < deletions; ++i) {
                entityIndex += entityBitBuffer.readUBitVar();
                // Entity wasn't dealt with in packet, but has been deleted
                frame.remove(entityIndex);
                this._removeEntity(entityIndex, false);
            }
        }
    }
    _parseInstanceBaseline(baselineBuf, classId) {
        const classBaseline = {};
        for (const bl of this._parseEntityUpdate(baselineBuf, classId)) {
            const tableName = bl.prop.table.netTableName;
            const varName = bl.prop.prop.varName;
            const table = classBaseline[tableName];
            if (table === undefined) {
                classBaseline[tableName] = { [varName]: bl.value };
            }
            else {
                table[varName] = bl.value;
            }
        }
        return classBaseline;
    }
    _handleUserInfoUpdate(clientSlot, oldPlayerInfo, playerInfo) {
        if (oldPlayerInfo != null) {
            this._userIdToEntity.delete(oldPlayerInfo.userId);
            this._steam64IdToEntity.delete(oldPlayerInfo.xuid.toString());
            this._accountNumberToEntity.delete(oldPlayerInfo.friendsId);
        }
        if (playerInfo != null) {
            this._userIdToEntity.set(playerInfo.userId, clientSlot + 1);
            this._steam64IdToEntity.set(playerInfo.xuid.toString(), clientSlot + 1);
            this._accountNumberToEntity.set(playerInfo.friendsId, clientSlot + 1);
        }
    }
    _handleInstanceBaselineUpdate(event) {
        if (!event.userData)
            return;
        const classId = parseInt(event.entry, 10);
        const baselineBuf = bitbuffer_1.BitStream.from(event.userData);
        if (!this.serverClasses[classId]) {
            this.pendingBaselines[classId] = baselineBuf;
            return;
        }
        const baseline = this._parseInstanceBaseline(baselineBuf, classId);
        this.staticBaselines[classId] = baseline;
        this.emit("baselineupdate", {
            classId,
            serverClass: this.serverClasses[classId],
            baseline
        });
    }
    _handleStringTableUpdate(event) {
        if (event.table.name === "userinfo") {
            this._handleUserInfoUpdate(event.entryIndex, event.oldUserData, event.userData);
        }
        else if (event.table.name === "instancebaseline") {
            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
            this._handleInstanceBaselineUpdate(event);
        }
    }
}
exports.Entities = Entities;

},{"./assert-exists":2,"./consts":3,"./entities/baseentity":8,"./entities/gamerules":9,"./entities/networkable":11,"./entities/player":12,"./entities/projectile":13,"./entities/team":14,"./entities/weapon":15,"./ext/bitbuffer":18,"./net":22,"./props":23,"assert":73,"events":84,"immutable":87,"iter-tools":473,"long":712}],8:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BaseEntity = void 0;
const networkable_1 = require("./networkable");
/**
 * Represents an in-game entity.
 */
class BaseEntity extends networkable_1.Networkable {
    /**
     * Position of this entity in the game world.
     * @returns World-space coordinates
     */
    get position() {
        const cellWidth = 1 << this.getProp("DT_BaseEntity", "m_cellbits");
        const cellX = this.getProp("DT_BaseEntity", "m_cellX");
        const cellY = this.getProp("DT_BaseEntity", "m_cellY");
        const cellZ = this.getProp("DT_BaseEntity", "m_cellZ");
        const cellOffset = this.getProp("DT_BaseEntity", "m_vecOrigin");
        return {
            x: cellX * cellWidth - 16384 + cellOffset.x,
            y: cellY * cellWidth - 16384 + cellOffset.y,
            z: cellZ * cellWidth - 16384 + cellOffset.z
        };
    }
    /**
     * @returns Entity which this entity is moving with, if any
     */
    get moveParent() {
        // UNSAFE: cast here as move parent will always be a proper entity
        return this._demo.entities.getByHandle(this.getProp("DT_BaseEntity", "moveparent"));
    }
    /**
     * @returns Owning entity, if any
     */
    get owner() {
        // UNSAFE: cast here as owner will always be a proper entity
        return this._demo.entities.getByHandle(this.getProp("DT_BaseEntity", "m_hOwnerEntity"));
    }
    /**
     * @returns Team number (0: Unassigned, 1: Spectator, 2: Terrorist, 3: Counter-Terrorist)
     */
    get teamNumber() {
        return this.getProp("DT_BaseEntity", "m_iTeamNum");
    }
    /**
     * @returns Team if assigned, null if unassigned.
     */
    get team() {
        const teamNum = this.teamNumber;
        if (teamNum === 0) {
            return null;
        }
        return this._demo.entities.teams[teamNum];
    }
    /**
     * @returns Name of the model that should be rendered for this entity. (e.g. 'models/Weapons/w_eq_smokegrenade_thrown.mdl')
     */
    get modelName() {
        const modelprecache = this._demo.stringTables.findTableByName("modelprecache");
        if (!modelprecache) {
            return null;
        }
        return modelprecache.entries[this.getProp("DT_BaseEntity", "m_nModelIndex")].entry;
    }
}
exports.BaseEntity = BaseEntity;

},{"./networkable":11}],9:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.GameRules = void 0;
const networkable_1 = require("./networkable");
/**
 * Represents the game rules.
 */
class GameRules extends networkable_1.Networkable {
    /**
     * @returns Is the game currently in 'warmup' mode?
     */
    get isWarmup() {
        return this.getProp("DT_CSGameRules", "m_bWarmupPeriod");
    }
    /**
     * @deprecated Use `GameRules#roundsPlayed` instead.
     */
    get roundNumber() {
        return this.roundsPlayed;
    }
    /**
     * This value is incremented when the scores are updated at round end.
     * If you need to keep track of the current round number, store this value
     * at each `round_start`.
     *
     * @returns Total number of rounds played.
     */
    get roundsPlayed() {
        return this.getProp("DT_CSGameRules", "m_totalRoundsPlayed");
    }
    /**
     * @returns 'first', 'second', 'halftime' or 'postgame'
     */
    get phase() {
        const gamePhases = {
            2: "first",
            3: "second",
            4: "halftime",
            5: "postgame"
        };
        const phase = this.getProp("DT_CSGameRules", "m_gamePhase");
        return gamePhases[phase];
    }
}
exports.GameRules = GameRules;

},{"./networkable":11}],10:[function(require,module,exports){
"use strict";
// DO NOT MODIFY!
// Auto-generated by ./generators/itemdefs.ts
Object.defineProperty(exports, "__esModule", { value: true });
exports.paintKitIndexMap = exports.itemDefinitionIndexMap = void 0;
exports.itemDefinitionIndexMap = {
    "1": {
        className: "weapon_deagle",
        itemName: "Desert Eagle"
    },
    "2": {
        className: "weapon_elite",
        itemName: "Dual Berettas"
    },
    "3": {
        className: "weapon_fiveseven",
        itemName: "Five-SeveN"
    },
    "4": {
        className: "weapon_glock",
        itemName: "Glock-18"
    },
    "7": {
        className: "weapon_ak47",
        itemName: "AK-47"
    },
    "8": {
        className: "weapon_aug",
        itemName: "AUG"
    },
    "9": {
        className: "weapon_awp",
        itemName: "AWP"
    },
    "10": {
        className: "weapon_famas",
        itemName: "FAMAS"
    },
    "11": {
        className: "weapon_g3sg1",
        itemName: "G3SG1"
    },
    "13": {
        className: "weapon_galilar",
        itemName: "Galil AR"
    },
    "14": {
        className: "weapon_m249",
        itemName: "M249"
    },
    "16": {
        className: "weapon_m4a1",
        itemName: "M4A4"
    },
    "17": {
        className: "weapon_mac10",
        itemName: "MAC-10"
    },
    "19": {
        className: "weapon_p90",
        itemName: "P90"
    },
    "20": {
        className: "weapon_zone_repulsor",
        itemName: "Repulsor Device"
    },
    "23": {
        className: "weapon_mp5sd",
        itemName: "MP5-SD"
    },
    "24": {
        className: "weapon_ump45",
        itemName: "UMP-45"
    },
    "25": {
        className: "weapon_xm1014",
        itemName: "XM1014"
    },
    "26": {
        className: "weapon_bizon",
        itemName: "PP-Bizon"
    },
    "27": {
        className: "weapon_mag7",
        itemName: "MAG-7"
    },
    "28": {
        className: "weapon_negev",
        itemName: "Negev"
    },
    "29": {
        className: "weapon_sawedoff",
        itemName: "Sawed-Off"
    },
    "30": {
        className: "weapon_tec9",
        itemName: "Tec-9"
    },
    "31": {
        className: "weapon_taser",
        itemName: "Zeus x27"
    },
    "32": {
        className: "weapon_hkp2000",
        itemName: "P2000"
    },
    "33": {
        className: "weapon_mp7",
        itemName: "MP7"
    },
    "34": {
        className: "weapon_mp9",
        itemName: "MP9"
    },
    "35": {
        className: "weapon_nova",
        itemName: "Nova"
    },
    "36": {
        className: "weapon_p250",
        itemName: "P250"
    },
    "37": {
        className: "weapon_shield",
        itemName: "Riot Shield"
    },
    "38": {
        className: "weapon_scar20",
        itemName: "SCAR-20"
    },
    "39": {
        className: "weapon_sg556",
        itemName: "SG 553"
    },
    "40": {
        className: "weapon_ssg08",
        itemName: "SSG 08"
    },
    "41": {
        className: "weapon_knifegg",
        itemName: "Knife"
    },
    "42": {
        className: "weapon_knife",
        itemName: "Knife"
    },
    "43": {
        className: "weapon_flashbang",
        itemName: "Flashbang"
    },
    "44": {
        className: "weapon_hegrenade",
        itemName: "High Explosive Grenade"
    },
    "45": {
        className: "weapon_smokegrenade",
        itemName: "Smoke Grenade"
    },
    "46": {
        className: "weapon_molotov",
        itemName: "Molotov"
    },
    "47": {
        className: "weapon_decoy",
        itemName: "Decoy Grenade"
    },
    "48": {
        className: "weapon_incgrenade",
        itemName: "Incendiary Grenade"
    },
    "49": {
        className: "weapon_c4",
        itemName: "C4 Explosive"
    },
    "57": {
        className: "weapon_healthshot",
        itemName: "Medi-Shot"
    },
    "59": {
        className: "weapon_knife_t",
        itemName: "Knife"
    },
    "60": {
        className: "weapon_m4a1_silencer",
        itemName: "M4A1-S"
    },
    "61": {
        className: "weapon_usp_silencer",
        itemName: "USP-S"
    },
    "63": {
        className: "weapon_cz75a",
        itemName: "CZ75-Auto"
    },
    "64": {
        className: "weapon_revolver",
        itemName: "R8 Revolver"
    },
    "68": {
        className: "weapon_tagrenade",
        itemName: "Tactical Awareness Grenade"
    },
    "69": {
        className: "weapon_fists",
        itemName: "Bare Hands"
    },
    "70": {
        className: "weapon_breachcharge",
        itemName: "Breach Charge"
    },
    "72": {
        className: "weapon_tablet",
        itemName: "Tablet"
    },
    "75": {
        className: "weapon_axe",
        itemName: "Axe"
    },
    "76": {
        className: "weapon_hammer",
        itemName: "Hammer"
    },
    "78": {
        className: "weapon_spanner",
        itemName: "Wrench"
    },
    "80": {
        className: "weapon_knife_ghost",
        itemName: "Knife"
    },
    "81": {
        className: "weapon_firebomb",
        itemName: "Fire Bomb"
    },
    "82": {
        className: "weapon_diversion",
        itemName: "Diversion Device"
    },
    "83": {
        className: "weapon_frag_grenade",
        itemName: "Frag Grenade"
    },
    "84": {
        className: "weapon_snowball",
        itemName: "Snowball"
    },
    "85": {
        className: "weapon_bumpmine",
        itemName: "Bump Mine"
    },
    "500": {
        className: "weapon_bayonet",
        itemName: "Bayonet"
    },
    "503": {
        className: "weapon_knife_css",
        itemName: "Classic Knife"
    },
    "505": {
        className: "weapon_knife_flip",
        itemName: "Flip Knife"
    },
    "506": {
        className: "weapon_knife_gut",
        itemName: "Gut Knife"
    },
    "507": {
        className: "weapon_knife_karambit",
        itemName: "Karambit"
    },
    "508": {
        className: "weapon_knife_m9_bayonet",
        itemName: "M9 Bayonet"
    },
    "509": {
        className: "weapon_knife_tactical",
        itemName: "Huntsman Knife"
    },
    "512": {
        className: "weapon_knife_falchion",
        itemName: "Falchion Knife"
    },
    "514": {
        className: "weapon_knife_survival_bowie",
        itemName: "Bowie Knife"
    },
    "515": {
        className: "weapon_knife_butterfly",
        itemName: "Butterfly Knife"
    },
    "516": {
        className: "weapon_knife_push",
        itemName: "Shadow Daggers"
    },
    "517": {
        className: "weapon_knife_cord",
        itemName: "Paracord Knife"
    },
    "518": {
        className: "weapon_knife_canis",
        itemName: "Survival Knife"
    },
    "519": {
        className: "weapon_knife_ursus",
        itemName: "Ursus Knife"
    },
    "520": {
        className: "weapon_knife_gypsy_jackknife",
        itemName: "Navaja Knife"
    },
    "521": {
        className: "weapon_knife_outdoor",
        itemName: "Nomad Knife"
    },
    "522": {
        className: "weapon_knife_stiletto",
        itemName: "Stiletto Knife"
    },
    "523": {
        className: "weapon_knife_widowmaker",
        itemName: "Talon Knife"
    },
    "525": {
        className: "weapon_knife_skeleton",
        itemName: "Skeleton Knife"
    }
};
exports.paintKitIndexMap = {
    "0": {
        name: "default",
        tag: "-"
    },
    "2": {
        name: "so_olive",
        tag: "Groundwater"
    },
    "3": {
        name: "so_red",
        tag: "Candy Apple"
    },
    "5": {
        name: "hy_ddpat",
        tag: "Forest DDPAT"
    },
    "6": {
        name: "hy_arctic",
        tag: "Arctic Camo"
    },
    "8": {
        name: "hy_desert",
        tag: "Desert Storm"
    },
    "9": {
        name: "hy_tiger",
        tag: "Bengal Tiger"
    },
    "10": {
        name: "hy_copperhead",
        tag: "Copperhead"
    },
    "11": {
        name: "hy_skulls",
        tag: "Skulls"
    },
    "12": {
        name: "hy_webs",
        tag: "Crimson Web"
    },
    "13": {
        name: "hy_splatter",
        tag: "Blue Streak"
    },
    "14": {
        name: "hy_ak47lam",
        tag: "Red Laminate"
    },
    "15": {
        name: "hy_gelpen",
        tag: "Gunsmoke"
    },
    "16": {
        name: "hy_v_tiger",
        tag: "Jungle Tiger"
    },
    "17": {
        name: "hy_ddpat_urb",
        tag: "Urban DDPAT"
    },
    "20": {
        name: "hy_zombie",
        tag: "Virus"
    },
    "21": {
        name: "hy_granite",
        tag: "Granite Marbleized"
    },
    "22": {
        name: "sp_spray",
        tag: "Contrast Spray"
    },
    "25": {
        name: "sp_leaves",
        tag: "Forest Leaves"
    },
    "26": {
        name: "sp_short_tape",
        tag: "Lichen Dashed"
    },
    "27": {
        name: "sp_tape",
        tag: "Bone Mask"
    },
    "28": {
        name: "an_navy",
        tag: "Anodized Navy"
    },
    "30": {
        name: "sp_snake",
        tag: "Snake Camo"
    },
    "32": {
        name: "an_silver",
        tag: "Silver"
    },
    "33": {
        name: "an_red",
        tag: "Hot Rod"
    },
    "34": {
        name: "am_urban",
        tag: "Metallic DDPAT"
    },
    "36": {
        name: "am_ossify",
        tag: "Ossified"
    },
    "37": {
        name: "aa_flames",
        tag: "Blaze"
    },
    "38": {
        name: "aa_fade",
        tag: "Fade"
    },
    "39": {
        name: "so_yellow",
        tag: "Bulldozer"
    },
    "40": {
        name: "so_night",
        tag: "Night"
    },
    "41": {
        name: "aq_copper",
        tag: "Copper"
    },
    "42": {
        name: "aq_blued",
        tag: "Blue Steel"
    },
    "43": {
        name: "aq_forced",
        tag: "Stained"
    },
    "44": {
        name: "aq_oiled",
        tag: "Case Hardened"
    },
    "46": {
        name: "so_pmc",
        tag: "Contractor"
    },
    "47": {
        name: "so_space_marine",
        tag: "Colony"
    },
    "48": {
        name: "am_dragon_glock",
        tag: "Dragon Tattoo"
    },
    "51": {
        name: "am_lightning_awp",
        tag: "Lightning Strike"
    },
    "59": {
        name: "am_zebra",
        tag: "Slaughter"
    },
    "60": {
        name: "am_zebra_dark",
        tag: "Dark Water"
    },
    "61": {
        name: "aa_vertigo",
        tag: "Hypnotic"
    },
    "62": {
        name: "cu_spring_nova",
        tag: "Bloomstick"
    },
    "67": {
        name: "am_slither_p90",
        tag: "Cold Blooded"
    },
    "70": {
        name: "am_carbon_fiber",
        tag: "Carbon Fiber"
    },
    "71": {
        name: "am_scorpion_p2000",
        tag: "Scorpion"
    },
    "72": {
        name: "sp_mesh_tan",
        tag: "Safari Mesh"
    },
    "73": {
        name: "hy_feathers_aug",
        tag: "Wings"
    },
    "74": {
        name: "hy_arctic_contrast",
        tag: "Polar Camo"
    },
    "75": {
        name: "hy_blizzard",
        tag: "Blizzard Marbleized"
    },
    "76": {
        name: "hy_forest_winter",
        tag: "Winter Forest"
    },
    "77": {
        name: "hy_forest_boreal",
        tag: "Boreal Forest"
    },
    "78": {
        name: "hy_forest_night",
        tag: "Forest Night"
    },
    "83": {
        name: "hy_ddpat_orange",
        tag: "Orange DDPAT"
    },
    "84": {
        name: "hy_ddpat_pink",
        tag: "Pink DDPAT"
    },
    "90": {
        name: "hy_mottled_sand",
        tag: "Mudder"
    },
    "92": {
        name: "hy_reef",
        tag: "Cyanospatter"
    },
    "93": {
        name: "so_caramel",
        tag: "Caramel"
    },
    "95": {
        name: "so_grassland",
        tag: "Grassland"
    },
    "96": {
        name: "so_moss",
        tag: "Blue Spruce"
    },
    "98": {
        name: "so_purple",
        tag: "Ultraviolet"
    },
    "99": {
        name: "so_sand",
        tag: "Sand Dune"
    },
    "100": {
        name: "so_stormfront",
        tag: "Storm"
    },
    "101": {
        name: "so_tornado",
        tag: "Tornado"
    },
    "102": {
        name: "so_whiteout",
        tag: "Whiteout"
    },
    "104": {
        name: "sp_leaves_grassland",
        tag: "Grassland Leaves"
    },
    "107": {
        name: "sp_mesh_arctic_contrast",
        tag: "Polar Mesh"
    },
    "110": {
        name: "sp_mesh_forest_fire",
        tag: "Condemned"
    },
    "111": {
        name: "sp_mesh_glacier",
        tag: "Glacier Mesh"
    },
    "116": {
        name: "sp_mesh_sand",
        tag: "Sand Mesh"
    },
    "119": {
        name: "sp_spray_desert_sage",
        tag: "Sage Spray"
    },
    "122": {
        name: "sp_spray_jungle",
        tag: "Jungle Spray"
    },
    "124": {
        name: "sp_spray_sand",
        tag: "Sand Spray"
    },
    "125": {
        name: "cu_xray_p250",
        tag: "X-Ray"
    },
    "135": {
        name: "sp_tape_dots_urban",
        tag: "Urban Perforated"
    },
    "136": {
        name: "sp_tape_dots_waves",
        tag: "Waves Perforated"
    },
    "141": {
        name: "sp_tape_orange",
        tag: "Orange Peel"
    },
    "143": {
        name: "sp_tape_urban",
        tag: "Urban Masked"
    },
    "147": {
        name: "sp_tape_short_jungle",
        tag: "Jungle Dashed"
    },
    "148": {
        name: "sp_tape_short_sand",
        tag: "Sand Dashed"
    },
    "149": {
        name: "sp_tape_short_urban",
        tag: "Urban Dashed"
    },
    "151": {
        name: "so_jungle",
        tag: "Jungle"
    },
    "153": {
        name: "so_tangerine",
        tag: "Demolition"
    },
    "154": {
        name: "cu_broken_path_famas",
        tag: "Afterimage"
    },
    "155": {
        name: "cu_bullet_rain_m4a1",
        tag: "Bullet Rain"
    },
    "156": {
        name: "cu_catskulls_p90",
        tag: "Death by Kitty"
    },
    "157": {
        name: "sp_palm",
        tag: "Palm"
    },
    "158": {
        name: "cu_walnut_nova",
        tag: "Walnut"
    },
    "159": {
        name: "aq_brass",
        tag: "Brass"
    },
    "162": {
        name: "sp_splash_p250",
        tag: "Splash"
    },
    "164": {
        name: "hy_hunter_modern",
        tag: "Modern Hunter"
    },
    "165": {
        name: "hy_hunter_blaze_pink",
        tag: "Splash Jam"
    },
    "166": {
        name: "hy_hunter_blaze_orange",
        tag: "Blaze Orange"
    },
    "167": {
        name: "sp_nukestripe_orange",
        tag: "Radiation Hazard"
    },
    "168": {
        name: "sp_nukestripe_green",
        tag: "Nuclear Threat"
    },
    "169": {
        name: "sp_nukestripe_maroon",
        tag: "Fallout Warning"
    },
    "170": {
        name: "sp_zebracam",
        tag: "Predator"
    },
    "171": {
        name: "sp_nukestripe_brown",
        tag: "Irradiated Alert"
    },
    "172": {
        name: "hy_ak47lam_bw",
        tag: "Black Laminate"
    },
    "174": {
        name: "hy_blam_simple",
        tag: "BOOM"
    },
    "175": {
        name: "sp_dapple",
        tag: "Scorched"
    },
    "176": {
        name: "sp_zebracam_bw",
        tag: "Faded Zebra"
    },
    "177": {
        name: "hy_icosahedron",
        tag: "Memento"
    },
    "178": {
        name: "hy_doomkitty",
        tag: "Doomkitty"
    },
    "179": {
        name: "sp_nukestripe_green_tec9",
        tag: "Nuclear Threat"
    },
    "180": {
        name: "cu_fireserpent_ak47_bravo",
        tag: "Fire Serpent"
    },
    "181": {
        name: "cu_favela_awp",
        tag: "Corticera"
    },
    "182": {
        name: "cu_dragon_p90_bravo",
        tag: "Emerald Dragon"
    },
    "183": {
        name: "hy_siege_bravo",
        tag: "Overgrowth"
    },
    "184": {
        name: "cu_favela_p2000",
        tag: "Corticera"
    },
    "185": {
        name: "am_scales_bravo",
        tag: "Golden Koi"
    },
    "186": {
        name: "sp_spray_waves_bravo",
        tag: "Wave Spray"
    },
    "187": {
        name: "sp_star_bravo",
        tag: "Zirka"
    },
    "188": {
        name: "aq_etched_mac10_bravo",
        tag: "Graven"
    },
    "189": {
        name: "hy_ocean_bravo",
        tag: "Bright Water"
    },
    "190": {
        name: "cu_season_elites_bravo",
        tag: "Black Limba"
    },
    "191": {
        name: "hy_seaside_bravo",
        tag: "Tempest"
    },
    "192": {
        name: "hy_crumple_bravo",
        tag: "Shattered"
    },
    "193": {
        name: "sp_skull_diagram_bravo",
        tag: "Bone Pile"
    },
    "194": {
        name: "sp_spitfire_famas_bravo",
        tag: "Spitfire"
    },
    "195": {
        name: "hy_bluepolygon_bravo",
        tag: "Demeter"
    },
    "196": {
        name: "an_emerald_bravo",
        tag: "Emerald"
    },
    "197": {
        name: "an_navy_bravo",
        tag: "Anodized Navy"
    },
    "198": {
        name: "sp_hazard_bravo",
        tag: "Hazard"
    },
    "199": {
        name: "sp_tape_dots_bravo",
        tag: "Dry Season"
    },
    "200": {
        name: "hy_mayan_dreams_bravo",
        tag: "Mayan Dreams"
    },
    "201": {
        name: "sp_palm_bravo",
        tag: "Palm"
    },
    "202": {
        name: "hy_ddpat_jungle_bravo",
        tag: "Jungle DDPAT"
    },
    "203": {
        name: "aq_steel_bravo",
        tag: "Rust Coat"
    },
    "204": {
        name: "hy_ali_tile_bravo",
        tag: "Mosaico"
    },
    "205": {
        name: "so_jungle_bravo",
        tag: "Jungle"
    },
    "206": {
        name: "so_tornado_bravo",
        tag: "Tornado"
    },
    "207": {
        name: "hy_crumple_dark_bravo",
        tag: "Facets"
    },
    "208": {
        name: "so_sand_bravo",
        tag: "Sand Dune"
    },
    "209": {
        name: "so_olive_bravo",
        tag: "Groundwater"
    },
    "210": {
        name: "an_gunmetal_bravo",
        tag: "Anodized Gunmetal"
    },
    "211": {
        name: "am_ossify_blue_p2000_bravo",
        tag: "Ocean Foam"
    },
    "212": {
        name: "am_crumple_bravo",
        tag: "Graphite"
    },
    "213": {
        name: "am_ossify_blue",
        tag: "Ocean Foam"
    },
    "214": {
        name: "am_crumple",
        tag: "Graphite"
    },
    "215": {
        name: "cu_xray_m4",
        tag: "X-Ray"
    },
    "216": {
        name: "an_titanium30v",
        tag: "Blue Titanium"
    },
    "217": {
        name: "hy_redtiger",
        tag: "Blood Tiger"
    },
    "218": {
        name: "hy_bluehex",
        tag: "Hexane"
    },
    "219": {
        name: "hy_redhex",
        tag: "Hive"
    },
    "220": {
        name: "am_ossify_red",
        tag: "Hemoglobin"
    },
    "221": {
        name: "am_electric_red",
        tag: "Serum"
    },
    "222": {
        name: "cu_shark",
        tag: "Blood in the Water"
    },
    "223": {
        name: "hy_flowers",
        tag: "Nightshade"
    },
    "224": {
        name: "hy_water_crest",
        tag: "Water Sigil"
    },
    "225": {
        name: "sp_camo_wood_blue",
        tag: "Ghost Camo"
    },
    "226": {
        name: "hy_ak47lam_blue",
        tag: "Blue Laminate"
    },
    "227": {
        name: "hy_hive",
        tag: "Electric Hive"
    },
    "228": {
        name: "hy_modspots",
        tag: "Blind Spot"
    },
    "229": {
        name: "sp_zebracam_blue",
        tag: "Azure Zebra"
    },
    "230": {
        name: "am_ddpatdense_silver",
        tag: "Steel Disruption"
    },
    "231": {
        name: "am_ddpatdense_peacock",
        tag: "Cobalt Disruption"
    },
    "232": {
        name: "hy_webs_darker",
        tag: "Crimson Web"
    },
    "233": {
        name: "sp_palm_shadow",
        tag: "Tropical Storm"
    },
    "234": {
        name: "sp_twigs",
        tag: "Ash Wood"
    },
    "235": {
        name: "hy_varicamo",
        tag: "VariCamo"
    },
    "236": {
        name: "hy_varicamo_night",
        tag: "Night Ops"
    },
    "237": {
        name: "hy_varicamo_urban",
        tag: "Urban Rubble"
    },
    "238": {
        name: "hy_varicamo_blue",
        tag: "VariCamo Blue"
    },
    "240": {
        name: "hy_varicamo_desert",
        tag: "CaliCamo"
    },
    "241": {
        name: "sp_mesh_slashes",
        tag: "Hunting Blind"
    },
    "242": {
        name: "sp_mesh_army",
        tag: "Army Mesh"
    },
    "243": {
        name: "sp_mesh_python",
        tag: "Gator Mesh"
    },
    "244": {
        name: "sp_mesh_hot_and_cold",
        tag: "Teardown"
    },
    "245": {
        name: "sp_spray_army",
        tag: "Army Recon"
    },
    "246": {
        name: "aa_fade_metallic",
        tag: "Amber Fade"
    },
    "247": {
        name: "aq_damascus_sg553",
        tag: "Damascus Steel"
    },
    "248": {
        name: "am_crystallized",
        tag: "Red Quartz"
    },
    "249": {
        name: "am_crystallized_blue",
        tag: "Cobalt Quartz"
    },
    "250": {
        name: "hy_varicamo_red",
        tag: "Full Stop"
    },
    "251": {
        name: "hy_snakeskin",
        tag: "Pit Viper"
    },
    "252": {
        name: "am_crystallized_silver",
        tag: "Silver Quartz"
    },
    "253": {
        name: "aa_fade_grassland",
        tag: "Acid Fade"
    },
    "254": {
        name: "so_orange_accents",
        tag: "Nitro"
    },
    "255": {
        name: "cu_m4_asimov",
        tag: "Asiimov"
    },
    "256": {
        name: "cu_sawedoff_octopump",
        tag: "The Kraken"
    },
    "257": {
        name: "cu_m4a1-s_elegant",
        tag: "Guardian"
    },
    "258": {
        name: "cu_p250_refined",
        tag: "Mehndi"
    },
    "259": {
        name: "cu_awp_cobra",
        tag: "Redline"
    },
    "260": {
        name: "cu_famas_pulse",
        tag: "Pulse"
    },
    "261": {
        name: "hy_marina_sunrise",
        tag: "Marina"
    },
    "262": {
        name: "am_thorny_rose_mp9",
        tag: "Rose Iron"
    },
    "263": {
        name: "cu_skull_nova",
        tag: "Rising Skull"
    },
    "264": {
        name: "cu_sandstorm",
        tag: "Sandstorm"
    },
    "265": {
        name: "hy_kami",
        tag: "Kami"
    },
    "266": {
        name: "aq_obsidian",
        tag: "Magma"
    },
    "267": {
        name: "am_turqoise_halftone",
        tag: "Cobalt Halftone"
    },
    "268": {
        name: "am_diamond_plate",
        tag: "Tread Plate"
    },
    "269": {
        name: "am_fuschia",
        tag: "The Fuschia Is Now"
    },
    "270": {
        name: "aq_etched_cz75",
        tag: "Victoria"
    },
    "271": {
        name: "am_p250_beaded_paint",
        tag: "Undertow"
    },
    "272": {
        name: "am_fluted_tec9",
        tag: "Titanium Bit"
    },
    "273": {
        name: "aq_engraved_deagle",
        tag: "Heirloom"
    },
    "274": {
        name: "am_copper_flecks",
        tag: "Copper Galaxy"
    },
    "275": {
        name: "hy_poly_camo",
        tag: "Red FragCam"
    },
    "276": {
        name: "so_panther",
        tag: "Panther"
    },
    "277": {
        name: "aq_usp_stainless",
        tag: "Stainless"
    },
    "278": {
        name: "hy_craquelure",
        tag: "Blue Fissure"
    },
    "279": {
        name: "cu_awp_asimov",
        tag: "Asiimov"
    },
    "280": {
        name: "cu_aug_chameleonaire",
        tag: "Chameleon"
    },
    "281": {
        name: "cu_ump_corporal",
        tag: "Corporal"
    },
    "282": {
        name: "cu_ak47_cobra",
        tag: "Redline"
    },
    "283": {
        name: "cu_p90_trigon",
        tag: "Trigon"
    },
    "284": {
        name: "cu_mac10_redhot",
        tag: "Heat"
    },
    "285": {
        name: "sp_negev_turq_terrain",
        tag: "Terrain"
    },
    "286": {
        name: "cu_nova_antique",
        tag: "Antique"
    },
    "287": {
        name: "cu_sg553_pulse",
        tag: "Pulse"
    },
    "288": {
        name: "an_famas_sgt",
        tag: "Sergeant"
    },
    "289": {
        name: "cu_tec9_sandstorm",
        tag: "Sandstorm"
    },
    "290": {
        name: "cu_usp_elegant",
        tag: "Guardian"
    },
    "291": {
        name: "cu_mag7_heaven",
        tag: "Heaven Guard"
    },
    "293": {
        name: "hy_nerodia",
        tag: "Death Rattle"
    },
    "294": {
        name: "so_green",
        tag: "Green Apple"
    },
    "295": {
        name: "cu_money",
        tag: "Franklin"
    },
    "296": {
        name: "am_crystallized_dark",
        tag: "Meteorite"
    },
    "297": {
        name: "so_orca",
        tag: "Tuxedo"
    },
    "298": {
        name: "am_army_shine",
        tag: "Army Sheen"
    },
    "299": {
        name: "am_oval_hex",
        tag: "Caged Steel"
    },
    "300": {
        name: "cu_pinstripe_ak47",
        tag: "Emerald Pinstripe"
    },
    "301": {
        name: "am_m4a1-s_alloy_orange",
        tag: "Atomic Alloy"
    },
    "302": {
        name: "cu_ak47_rubber",
        tag: "Vulcan"
    },
    "303": {
        name: "cu_tec9_asiimov",
        tag: "Isaac"
    },
    "304": {
        name: "cu_ssg08_immortal",
        tag: "Slashed"
    },
    "305": {
        name: "cu_aug_progressiv",
        tag: "Torque"
    },
    "306": {
        name: "cu_bizon_antique",
        tag: "Antique"
    },
    "307": {
        name: "cu_retribution",
        tag: "Retribution"
    },
    "308": {
        name: "hy_galil_kami",
        tag: "Kami"
    },
    "309": {
        name: "cu_m4a1_howling",
        tag: "Howl"
    },
    "310": {
        name: "cu_mac10_decay",
        tag: "Curse"
    },
    "311": {
        name: "cu_p90_scorpius",
        tag: "Desert Warfare"
    },
    "312": {
        name: "cu_scar_cyrex",
        tag: "Cyrex"
    },
    "313": {
        name: "cu_usp_spitfire",
        tag: "Orion"
    },
    "314": {
        name: "cu_xm1014_heaven_guard",
        tag: "Heaven Guard"
    },
    "315": {
        name: "am_nitrogen",
        tag: "Poison Dart"
    },
    "316": {
        name: "cu_panther_ak47",
        tag: "Jaguar"
    },
    "317": {
        name: "cu_bratatat_negev",
        tag: "Bratatat"
    },
    "318": {
        name: "cu_usp_sandpapered",
        tag: "Road Rash"
    },
    "319": {
        name: "hy_ssg08_marker",
        tag: "Detour"
    },
    "320": {
        name: "hy_snakeskin_red",
        tag: "Red Python"
    },
    "321": {
        name: "cu_m4a1-s_silence",
        tag: "Master Piece"
    },
    "322": {
        name: "so_orange_accents2",
        tag: "Nitro"
    },
    "323": {
        name: "aq_steel",
        tag: "Rust Coat"
    },
    "325": {
        name: "am_royal",
        tag: "Chalice"
    },
    "326": {
        name: "am_metals",
        tag: "Knight"
    },
    "327": {
        name: "am_chainmail",
        tag: "Chainmail"
    },
    "328": {
        name: "aq_handcannon",
        tag: "Hand Cannon"
    },
    "329": {
        name: "am_metal_inlay",
        tag: "Dark Age"
    },
    "330": {
        name: "hy_vines",
        tag: "Briar"
    },
    "332": {
        name: "hy_indigo_usp",
        tag: "Royal Blue"
    },
    "333": {
        name: "so_indigo_and_grey",
        tag: "Indigo"
    },
    "334": {
        name: "am_gyrate",
        tag: "Twist"
    },
    "335": {
        name: "an_royalbleed",
        tag: "Module"
    },
    "336": {
        name: "cu_titanstorm",
        tag: "Desert-Strike"
    },
    "337": {
        name: "cu_korupt",
        tag: "Tatter"
    },
    "338": {
        name: "cu_p2000_pulse",
        tag: "Pulse"
    },
    "339": {
        name: "cu_kaiman",
        tag: "Caiman"
    },
    "340": {
        name: "cu_well_traveled_ak47",
        tag: "Jet Set"
    },
    "341": {
        name: "cu_green_leather_ak47",
        tag: "First Class"
    },
    "342": {
        name: "cu_brown_leather_p90",
        tag: "Leather"
    },
    "343": {
        name: "cu_luggage_mac10",
        tag: "Commuter"
    },
    "344": {
        name: "cu_medieval_dragon_awp",
        tag: "Dragon Lore"
    },
    "345": {
        name: "cu_green_leather_sawedoff",
        tag: "First Class"
    },
    "346": {
        name: "cu_luggage_p2000",
        tag: "Coach Class"
    },
    "347": {
        name: "aq_pilot_deagle",
        tag: "Pilot"
    },
    "348": {
        name: "cu_leather_xm1014",
        tag: "Red Leather"
    },
    "349": {
        name: "cu_bizon-osiris",
        tag: "Osiris"
    },
    "350": {
        name: "cu_c75a-tiger",
        tag: "Tigris"
    },
    "351": {
        name: "cu_deagle_aureus",
        tag: "Conspiracy"
    },
    "352": {
        name: "aq_57_feathers",
        tag: "Fowl Play"
    },
    "353": {
        name: "cu_glock-liquescent",
        tag: "Water Elemental"
    },
    "354": {
        name: "cu_mp7-commander",
        tag: "Urban Hazard"
    },
    "355": {
        name: "cu_negev_titanstorm",
        tag: "Desert-Strike"
    },
    "356": {
        name: "cu_nova_koi",
        tag: "Koi"
    },
    "357": {
        name: "cu_p2000_ivory",
        tag: "Ivory"
    },
    "358": {
        name: "cu_bittersweet",
        tag: "Supernova"
    },
    "359": {
        name: "cu_p90-asiimov",
        tag: "Asiimov"
    },
    "360": {
        name: "cu_m4a1s_cyrex",
        tag: "Cyrex"
    },
    "361": {
        name: "aq_leviathan",
        tag: "Abyss"
    },
    "362": {
        name: "hy_lines_orange",
        tag: "Labyrinth"
    },
    "363": {
        name: "cu_luggage_sg553",
        tag: "Traveler"
    },
    "364": {
        name: "cu_luggage_usp-s",
        tag: "Business Class"
    },
    "365": {
        name: "hy_plaid1",
        tag: "Olive Plaid"
    },
    "366": {
        name: "hy_plaid2",
        tag: "Green Plaid"
    },
    "367": {
        name: "am_nuclear_pattern1_glock",
        tag: "Reactor"
    },
    "368": {
        name: "hy_nuclear_pattern2_mp9",
        tag: "Setting Sun"
    },
    "369": {
        name: "sp_nuclear_pattern3_negev",
        tag: "Nuclear Waste"
    },
    "370": {
        name: "am_nuclear_skulls1_xm1014",
        tag: "Bone Machine"
    },
    "371": {
        name: "am_nuclear_skulls2_famas",
        tag: "Styx"
    },
    "372": {
        name: "am_nuclear_skulls3_mac10",
        tag: "Nuclear Garden"
    },
    "373": {
        name: "hy_nuclear_skulls4_p250",
        tag: "Contamination"
    },
    "374": {
        name: "hy_nuclear_skulls5_tec9",
        tag: "Toxic"
    },
    "375": {
        name: "sp_nukestripe_orange_aug",
        tag: "Radiation Hazard"
    },
    "376": {
        name: "so_grey_nuclear_green_bizon",
        tag: "Chemical Green"
    },
    "377": {
        name: "so_grey_nuclear_orange_five_seven",
        tag: "Hot Shot"
    },
    "378": {
        name: "sp_nukestripe_maroon_sg553",
        tag: "Fallout Warning"
    },
    "379": {
        name: "cu_cerbrus_galil",
        tag: "Cerberus"
    },
    "380": {
        name: "cu_tribute_ak47",
        tag: "Wasteland Rebel"
    },
    "381": {
        name: "aq_glock_coiled",
        tag: "Grinder"
    },
    "382": {
        name: "am_g3sg1_murky",
        tag: "Murky"
    },
    "383": {
        name: "aq_m4a1s_basilisk",
        tag: "Basilisk"
    },
    "384": {
        name: "cu_m4a4_griffin",
        tag: "Griffin"
    },
    "385": {
        name: "sp_mag7_firebitten",
        tag: "Firestarter"
    },
    "386": {
        name: "cu_mp9_chevron",
        tag: "Dart"
    },
    "387": {
        name: "cu_fiveseven_urban_hazard",
        tag: "Urban Hazard"
    },
    "388": {
        name: "aq_p250_cartel",
        tag: "Cartel"
    },
    "389": {
        name: "cu_p2000_fire_elemental",
        tag: "Fire Elemental"
    },
    "390": {
        name: "aq_sawedoff_blackgold",
        tag: "Highwayman"
    },
    "391": {
        name: "cu_scar20_intervention",
        tag: "Cardiac"
    },
    "392": {
        name: "sp_ump45_d-visions",
        tag: "Delusion"
    },
    "393": {
        name: "cu_xm1014_caritas",
        tag: "Tranquility"
    },
    "394": {
        name: "aq_ak47_cartel",
        tag: "Cartel"
    },
    "395": {
        name: "am_awp_glory",
        tag: "Man-o'-war"
    },
    "396": {
        name: "cu_elites_urbanstorm",
        tag: "Urban Shock"
    },
    "397": {
        name: "aq_deagle_naga",
        tag: "Naga"
    },
    "398": {
        name: "cu_galil_abrasion",
        tag: "Chatterbox"
    },
    "399": {
        name: "cu_glock_deathtoll",
        tag: "Catacombs"
    },
    "400": {
        name: "cu_m4a4_ancestral",
        tag: "龍王 (Dragon King)"
    },
    "401": {
        name: "cu_m249_sektor",
        tag: "System Lock"
    },
    "402": {
        name: "am_mac10_malachite",
        tag: "Malachite"
    },
    "403": {
        name: "cu_mp9_deadly_poison",
        tag: "Deadly Poison"
    },
    "404": {
        name: "cu_p250_mandala",
        tag: "Muertos"
    },
    "405": {
        name: "cu_sawedoff_deva",
        tag: "Serenity"
    },
    "406": {
        name: "aq_scar20_leak",
        tag: "Grotto"
    },
    "407": {
        name: "aq_xm1014_sigla",
        tag: "Quicksilver"
    },
    "409": {
        name: "an_tiger_orange",
        tag: "Tiger Tooth"
    },
    "410": {
        name: "aq_damascus",
        tag: "Damascus Steel"
    },
    "411": {
        name: "aq_damascus_90",
        tag: "Damascus Steel"
    },
    "413": {
        name: "am_marble_fade",
        tag: "Marble Fade"
    },
    "414": {
        name: "aq_steel_knife",
        tag: "Rust Coat"
    },
    "415": {
        name: "am_ruby_marbleized",
        tag: "Doppler"
    },
    "416": {
        name: "am_sapphire_marbleized",
        tag: "Doppler"
    },
    "417": {
        name: "am_blackpearl_marbleized",
        tag: "Doppler"
    },
    "418": {
        name: "am_doppler_phase1",
        tag: "Doppler"
    },
    "419": {
        name: "am_doppler_phase2",
        tag: "Doppler"
    },
    "420": {
        name: "am_doppler_phase3",
        tag: "Doppler"
    },
    "421": {
        name: "am_doppler_phase4",
        tag: "Doppler"
    },
    "422": {
        name: "cu_ak47_mastery",
        tag: "Elite Build"
    },
    "423": {
        name: "aq_mp7_ultramodern",
        tag: "Armor Core"
    },
    "424": {
        name: "aq_awp_twine",
        tag: "Worm God"
    },
    "425": {
        name: "am_bronze_sparkle",
        tag: "Bronze Deco"
    },
    "426": {
        name: "aq_p250_contour",
        tag: "Valence"
    },
    "427": {
        name: "cu_fiveseven_banana",
        tag: "Monkey Business"
    },
    "428": {
        name: "cu_galil_eco",
        tag: "Eco"
    },
    "429": {
        name: "aq_famas_jinn",
        tag: "Djinn"
    },
    "430": {
        name: "cu_m4a1_hyper_beast",
        tag: "Hyper Beast"
    },
    "431": {
        name: "cu_mag7_redhot",
        tag: "Heat"
    },
    "432": {
        name: "am_negev_glory",
        tag: "Man-o'-war"
    },
    "433": {
        name: "cu_mac10_neonrider",
        tag: "Neon Rider"
    },
    "434": {
        name: "cu_sawedoff_origami",
        tag: "Origami"
    },
    "435": {
        name: "cu_cz75_precision",
        tag: "Pole Position"
    },
    "436": {
        name: "am_ump_racer",
        tag: "Grand Prix"
    },
    "437": {
        name: "am_aqua_flecks",
        tag: "Twilight Galaxy"
    },
    "438": {
        name: "cu_chronos_g3sg1",
        tag: "Chronos"
    },
    "439": {
        name: "hy_hades",
        tag: "Hades"
    },
    "440": {
        name: "hy_icarus",
        tag: "Icarus Fell"
    },
    "441": {
        name: "cu_labyrinth",
        tag: "Minotaur's Labyrinth"
    },
    "442": {
        name: "sp_labyrinth",
        tag: "Asterion"
    },
    "443": {
        name: "sp_labyrinth2",
        tag: "Pathfinder"
    },
    "444": {
        name: "sp_labyrinth3",
        tag: "Daedalus"
    },
    "445": {
        name: "an_red_m4a1s",
        tag: "Hot Rod"
    },
    "446": {
        name: "cu_medusa_awp",
        tag: "Medusa"
    },
    "447": {
        name: "gs_mother_of_pearl_elite",
        tag: "Duelist"
    },
    "448": {
        name: "aa_pandora",
        tag: "Pandora's Box"
    },
    "449": {
        name: "cu_poseidon",
        tag: "Poseidon"
    },
    "450": {
        name: "hy_zodiac1",
        tag: "Moon in Libra"
    },
    "451": {
        name: "hy_zodiac2",
        tag: "Sun in Leo"
    },
    "452": {
        name: "hy_zodiac3",
        tag: "Shipping Forecast"
    },
    "453": {
        name: "an_emerald",
        tag: "Emerald"
    },
    "454": {
        name: "so_khaki_green",
        tag: "Para Green"
    },
    "455": {
        name: "cu_anime_aug",
        tag: "Akihabara Accept"
    },
    "456": {
        name: "am_bamboo_jungle",
        tag: "Hydroponic"
    },
    "457": {
        name: "hy_bamboo_jungle_ink",
        tag: "Bamboo Print"
    },
    "458": {
        name: "hy_bamboo_jungle_black",
        tag: "Bamboo Shadow"
    },
    "459": {
        name: "hy_bamboo_jungle",
        tag: "Bamboo Forest"
    },
    "460": {
        name: "am_geometric_steps",
        tag: "Aqua Terrace"
    },
    "462": {
        name: "hy_geometric_steps_green",
        tag: "Counter Terrace"
    },
    "463": {
        name: "hy_geometric_steps_yellow",
        tag: "Terrace"
    },
    "464": {
        name: "hy_kimono_diamonds",
        tag: "Neon Kimono"
    },
    "465": {
        name: "hy_kimono_diamonds_orange",
        tag: "Orange Kimono"
    },
    "466": {
        name: "hy_kimono_diamonds_red",
        tag: "Crimson Kimono"
    },
    "467": {
        name: "sp_kimono_diamonds",
        tag: "Mint Kimono"
    },
    "468": {
        name: "am_seastorm",
        tag: "Midnight Storm"
    },
    "469": {
        name: "am_seastorm_blood",
        tag: "Sunset Storm 壱"
    },
    "470": {
        name: "am_seastorm_shojo",
        tag: "Sunset Storm 弐"
    },
    "471": {
        name: "am_kimono_sunrise",
        tag: "Daybreak"
    },
    "472": {
        name: "so_keycolors",
        tag: "Impact Drill"
    },
    "473": {
        name: "so_aqua",
        tag: "Seabird"
    },
    "474": {
        name: "cu_ak47_courage_alt",
        tag: "Aquamarine Revenge"
    },
    "475": {
        name: "cu_awp_hyper_beast",
        tag: "Hyper Beast"
    },
    "476": {
        name: "cu_cz75a_chastizer",
        tag: "Yellow Jacket"
    },
    "477": {
        name: "am_famas_dots",
        tag: "Neural Net"
    },
    "478": {
        name: "cu_galilar_particles",
        tag: "Rocket Pop"
    },
    "479": {
        name: "aq_glock18_flames_blue",
        tag: "Bunsen Burner"
    },
    "480": {
        name: "cu_m4a4_evil_daimyo",
        tag: "Evil Daimyo"
    },
    "481": {
        name: "cu_mp7_nemsis",
        tag: "Nemesis"
    },
    "482": {
        name: "am_mp9_nitrogen",
        tag: "Ruby Poison Dart"
    },
    "483": {
        name: "cu_negev_annihilator",
        tag: "Loudmouth"
    },
    "484": {
        name: "cu_nova_ranger",
        tag: "Ranger"
    },
    "485": {
        name: "aq_p2000_boom",
        tag: "Handgun"
    },
    "486": {
        name: "cu_p90_mastery",
        tag: "Elite Build"
    },
    "487": {
        name: "cu_sg553_cyrex",
        tag: "Cyrex"
    },
    "488": {
        name: "cu_ump45_uproar",
        tag: "Riot"
    },
    "489": {
        name: "cu_usp_progressiv",
        tag: "Torque"
    },
    "490": {
        name: "cu_ak47_winter_sport",
        tag: "Frontside Misty"
    },
    "491": {
        name: "cu_dualberretta_dragons",
        tag: "Dualing Dragons"
    },
    "492": {
        name: "cu_famas_lenta",
        tag: "Survivor Z"
    },
    "493": {
        name: "gs_g3sg1_flux_purple",
        tag: "Flux"
    },
    "494": {
        name: "gs_galil_nightwing",
        tag: "Stone Cold"
    },
    "495": {
        name: "gs_glock18_wrathys",
        tag: "Wraiths"
    },
    "496": {
        name: "gs_m249_nebula_crusader",
        tag: "Nebula Crusader"
    },
    "497": {
        name: "gs_m4a1s_snakebite_gold",
        tag: "Golden Coil"
    },
    "498": {
        name: "cu_mac10_alekhya_duo",
        tag: "Rangeen"
    },
    "499": {
        name: "cu_mag7_myrcene",
        tag: "Cobalt Core"
    },
    "500": {
        name: "cu_mp7_classified",
        tag: "Special Delivery"
    },
    "501": {
        name: "hy_p250_crackshot",
        tag: "Wingshot"
    },
    "502": {
        name: "gs_scar20_peacemaker03",
        tag: "Green Marine"
    },
    "503": {
        name: "cu_ssg08_technicality",
        tag: "Big Iron"
    },
    "504": {
        name: "cu_usp_kill_confirmed",
        tag: "Kill Confirmed"
    },
    "505": {
        name: "aq_xm1014_scumbria",
        tag: "Scumbria"
    },
    "506": {
        name: "cu_ak47_point_disarray",
        tag: "Point Disarray"
    },
    "507": {
        name: "am_aug_jumble",
        tag: "Ricochet"
    },
    "508": {
        name: "cu_bizon_noxious",
        tag: "Fuel Rod"
    },
    "509": {
        name: "aq_deagle_corinthian",
        tag: "Corinthian"
    },
    "510": {
        name: "cu_fiveseven_retrobution",
        tag: "Retrobution"
    },
    "511": {
        name: "cu_g3sg1_executioner",
        tag: "The Executioner"
    },
    "512": {
        name: "gs_m4a4_royal_squire",
        tag: "Royal Paladin"
    },
    "514": {
        name: "cu_negev_impact",
        tag: "Power Loader"
    },
    "515": {
        name: "am_p2000_imperial_red",
        tag: "Imperial"
    },
    "516": {
        name: "cu_p90_shapewood",
        tag: "Shapewood"
    },
    "517": {
        name: "gs_sawedoff_necromancer",
        tag: "Yorick"
    },
    "518": {
        name: "hy_scar20_jungler",
        tag: "Outbreak"
    },
    "519": {
        name: "gs_sg553_tiger_moth",
        tag: "Tiger Moth"
    },
    "520": {
        name: "cu_tec9_avalanche",
        tag: "Avalanche"
    },
    "521": {
        name: "aq_xm1014_hot_rod",
        tag: "Teclu Burner"
    },
    "522": {
        name: "aa_fade_revolver",
        tag: "Fade"
    },
    "523": {
        name: "aa_fade_metallic_revolver",
        tag: "Amber Fade"
    },
    "524": {
        name: "gs_ak47_supercharged",
        tag: "Fuel Injector"
    },
    "525": {
        name: "cu_awp_mastery",
        tag: "Elite Build"
    },
    "526": {
        name: "cu_bizon_citizen",
        tag: "Photic Zone"
    },
    "527": {
        name: "aq_deserteagle_kumichodragon",
        tag: "Kumicho Dragon"
    },
    "528": {
        name: "aq_dualberettas_cartel",
        tag: "Cartel"
    },
    "529": {
        name: "aq_famas_contour",
        tag: "Valence"
    },
    "530": {
        name: "cu_fiveseven_augmented",
        tag: "Triumvirate"
    },
    "532": {
        name: "gs_glock18_award",
        tag: "Royal Legion"
    },
    "533": {
        name: "gs_m4a4_pioneer",
        tag: "The Battlestar"
    },
    "534": {
        name: "am_mac10_electricity",
        tag: "Lapis Gator"
    },
    "535": {
        name: "gs_mag7_praetorian",
        tag: "Praetorian"
    },
    "536": {
        name: "sp_mp7_impire",
        tag: "Impire"
    },
    "537": {
        name: "cu_nova_hyperbeast",
        tag: "Hyper Beast"
    },
    "538": {
        name: "cu_ssg08_necropos",
        tag: "Necropos"
    },
    "539": {
        name: "gs_tec9_jambiya",
        tag: "Jambiya"
    },
    "540": {
        name: "gs_usp_voltage",
        tag: "Lead Conduit"
    },
    "541": {
        name: "cu_aug_swallows",
        tag: "Fleet Flock"
    },
    "542": {
        name: "cu_bizon_Curse",
        tag: "Judgement of Anubis"
    },
    "543": {
        name: "gs_cz75a_redastor",
        tag: "Red Astor"
    },
    "544": {
        name: "gs_dualberettas_ventilators",
        tag: "Ventilators"
    },
    "545": {
        name: "sp_g3sg1_militiaorange",
        tag: "Orange Crash"
    },
    "546": {
        name: "gs_galilar_incenerator",
        tag: "Firefight"
    },
    "547": {
        name: "cu_m249_spectre",
        tag: "Spectre"
    },
    "548": {
        name: "cu_m4a1s_soultaker",
        tag: "Chantico's Fire"
    },
    "549": {
        name: "am_mp9_bioleak",
        tag: "Bioleak"
    },
    "550": {
        name: "hy_p2000_oceani",
        tag: "Oceanic"
    },
    "551": {
        name: "cu_p250_asiimov",
        tag: "Asiimov"
    },
    "552": {
        name: "gs_sawedoff_fubar",
        tag: "Fubar"
    },
    "553": {
        name: "cu_sg553_atlas",
        tag: "Atlas"
    },
    "554": {
        name: "gs_ssg08_armacore",
        tag: "Ghost Crusader"
    },
    "555": {
        name: "am_tec9_redblast",
        tag: "Re-Entry"
    },
    "556": {
        name: "cu_ump45_primalsaber",
        tag: "Primal Saber"
    },
    "557": {
        name: "cu_xm1014_spectrum",
        tag: "Black Tie"
    },
    "558": {
        name: "cu_bayonet_lore",
        tag: "Lore"
    },
    "559": {
        name: "cu_flip_lore",
        tag: "Lore"
    },
    "560": {
        name: "cu_gut_lore",
        tag: "Lore"
    },
    "561": {
        name: "cu_karam_lore",
        tag: "Lore"
    },
    "562": {
        name: "cu_m9_bay_lore",
        tag: "Lore"
    },
    "563": {
        name: "cu_bayonet_stonewash",
        tag: "Black Laminate"
    },
    "564": {
        name: "cu_flip_stonewash",
        tag: "Black Laminate"
    },
    "565": {
        name: "cu_gut_stonewash",
        tag: "Black Laminate"
    },
    "566": {
        name: "cu_karam_stonewash",
        tag: "Black Laminate"
    },
    "567": {
        name: "cu_m9_bay_stonewash",
        tag: "Black Laminate"
    },
    "568": {
        name: "am_emerald_marbleized",
        tag: "Gamma Doppler"
    },
    "569": {
        name: "am_gamma_doppler_phase1",
        tag: "Gamma Doppler"
    },
    "570": {
        name: "am_gamma_doppler_phase2",
        tag: "Gamma Doppler"
    },
    "571": {
        name: "am_gamma_doppler_phase3",
        tag: "Gamma Doppler"
    },
    "572": {
        name: "am_gamma_doppler_phase4",
        tag: "Gamma Doppler"
    },
    "573": {
        name: "gs_bayonet_autotronic",
        tag: "Autotronic"
    },
    "574": {
        name: "gs_flip_autotronic",
        tag: "Autotronic"
    },
    "575": {
        name: "gs_gut_autotronic",
        tag: "Autotronic"
    },
    "576": {
        name: "gs_karam_autotronic",
        tag: "Autotronic"
    },
    "577": {
        name: "gs_m9_bay_autotronic",
        tag: "Autotronic"
    },
    "578": {
        name: "hy_ocean_knife",
        tag: "Bright Water"
    },
    "579": {
        name: "hy_ocean_knife_90",
        tag: "Bright Water"
    },
    "580": {
        name: "am_marked_up",
        tag: "Freehand"
    },
    "581": {
        name: "am_marked_up_90",
        tag: "Freehand"
    },
    "582": {
        name: "am_marked_up_fine",
        tag: "Freehand"
    },
    "583": {
        name: "gs_aug_aristocrat",
        tag: "Aristocrat"
    },
    "584": {
        name: "gs_awp_phobos",
        tag: "Phobos"
    },
    "585": {
        name: "cu_five_seven_daimyo",
        tag: "Violent Daimyo"
    },
    "586": {
        name: "cu_glock_wasteland_rebel",
        tag: "Wasteland Rebel"
    },
    "587": {
        name: "gs_m4a1_mecha_industries",
        tag: "Mecha Industries"
    },
    "588": {
        name: "cu_m4a4_desolate_space",
        tag: "Desolate Space"
    },
    "589": {
        name: "aq_mac_10_alien_camo",
        tag: "Carnivore"
    },
    "590": {
        name: "aq_nova_sci_fi",
        tag: "Exo"
    },
    "591": {
        name: "gs_p2000_imperial_dragon",
        tag: "Imperial Dragon"
    },
    "592": {
        name: "gs_p250_metal_panels",
        tag: "Iron Clad"
    },
    "593": {
        name: "gs_p90_full_throttle",
        tag: "Chopper"
    },
    "594": {
        name: "gs_pp_bizon_harvester",
        tag: "Harvester"
    },
    "595": {
        name: "cu_r8_cybersport",
        tag: "Reboot"
    },
    "596": {
        name: "cu_sawed_off_lime",
        tag: "Limelight"
    },
    "597": {
        name: "gs_scar20_bloodsport",
        tag: "Bloodsport"
    },
    "598": {
        name: "cu_sg553_aerial",
        tag: "Aerial"
    },
    "599": {
        name: "am_tec_9_sea_salt",
        tag: "Ice Cap"
    },
    "600": {
        name: "cu_ak47_anarchy",
        tag: "Neon Revolution"
    },
    "601": {
        name: "gs_aug_syd_mead",
        tag: "Syd Mead"
    },
    "602": {
        name: "gs_cz75_tread",
        tag: "Imprint"
    },
    "603": {
        name: "aq_desert_eagle_constable",
        tag: "Directive"
    },
    "604": {
        name: "gs_famas_rally",
        tag: "Roll Cage"
    },
    "605": {
        name: "aq_five_seven_scumbria",
        tag: "Scumbria"
    },
    "606": {
        name: "gs_g3sg1_ventilator",
        tag: "Ventilator"
    },
    "607": {
        name: "cu_glock18_weasel",
        tag: "Weasel"
    },
    "608": {
        name: "cu_mag7_tribal",
        tag: "Petroglyph"
    },
    "609": {
        name: "cu_mp9_narcis",
        tag: "Airlock"
    },
    "610": {
        name: "hy_negev_dazzle",
        tag: "Dazzle"
    },
    "611": {
        name: "cu_p90_grimm",
        tag: "Grim"
    },
    "612": {
        name: "gs_scar20_powercore",
        tag: "Powercore"
    },
    "613": {
        name: "cu_sg556_triarch",
        tag: "Triarch"
    },
    "614": {
        name: "gs_tec9_supercharged",
        tag: "Fuel Injector"
    },
    "615": {
        name: "cu_ump45_metritera",
        tag: "Briefing"
    },
    "616": {
        name: "hy_xm1014_fractal_blue",
        tag: "Slipstream"
    },
    "617": {
        name: "am_blackpearl_marbleized_b",
        tag: "Doppler"
    },
    "618": {
        name: "am_doppler_phase2_b",
        tag: "Doppler"
    },
    "619": {
        name: "am_sapphire_marbleized_b",
        tag: "Doppler"
    },
    "620": {
        name: "cu_purple_huntsman",
        tag: "Ultraviolet"
    },
    "621": {
        name: "so_purple_falchion",
        tag: "Ultraviolet"
    },
    "622": {
        name: "am_czv2_mf",
        tag: "Polymer"
    },
    "623": {
        name: "aq_glock_dark-fall",
        tag: "Ironwork"
    },
    "624": {
        name: "cu_ssg08_dragonfire_scope",
        tag: "Dragonfire"
    },
    "625": {
        name: "gs_dual_berettas_golden_venice",
        tag: "Royal Consorts"
    },
    "626": {
        name: "gs_famas_mecha",
        tag: "Mecha Industries"
    },
    "627": {
        name: "gs_final_pooldeadv2",
        tag: "Cirrus"
    },
    "628": {
        name: "gs_g3sg1_viper_yellow",
        tag: "Stinger"
    },
    "629": {
        name: "cu_galil_ar-camo",
        tag: "Black Sand"
    },
    "630": {
        name: "aa_hide-mp9",
        tag: "Sand Scale"
    },
    "631": {
        name: "cu_m4a1_flashback",
        tag: "Flashback"
    },
    "632": {
        name: "gs_m4a4_sector",
        tag: "Buzz Kill"
    },
    "633": {
        name: "am_mag7_malform",
        tag: "Sonar"
    },
    "634": {
        name: "am_nova_sand",
        tag: "Gila"
    },
    "635": {
        name: "gs_p2000-sport",
        tag: "Turf"
    },
    "636": {
        name: "gs_p90_shallow_grave",
        tag: "Shallow Grave"
    },
    "637": {
        name: "cu_usp_cyrex",
        tag: "Cyrex"
    },
    "638": {
        name: "cu_wp_sawedoff",
        tag: "Wasteland Princess"
    },
    "639": {
        name: "gs_ak47_bloodsport",
        tag: "Bloodsport"
    },
    "640": {
        name: "cu_awp_psychopath",
        tag: "Fever Dream"
    },
    "641": {
        name: "hy_bizon_torn_green",
        tag: "Jungle Slipstream"
    },
    "642": {
        name: "cu_blueprint_scar",
        tag: "Blueprint"
    },
    "643": {
        name: "gs_cz_snakes_purple",
        tag: "Xiangliu"
    },
    "644": {
        name: "gs_m4a1_decimator",
        tag: "Decimator"
    },
    "645": {
        name: "cu_desert_eagle_corroden",
        tag: "Oxide Blaze"
    },
    "646": {
        name: "cu_fiveseven_vein",
        tag: "Capillary"
    },
    "647": {
        name: "sp_galil_wave",
        tag: "Crimson Tsunami"
    },
    "648": {
        name: "sp_m249_frog_original",
        tag: "Emerald Poison Dart"
    },
    "649": {
        name: "sp_mp7_tribal_yellow",
        tag: "Akoben"
    },
    "650": {
        name: "am_p250_sputnik",
        tag: "Ripple"
    },
    "651": {
        name: "aa_mac10_the_last_dive",
        tag: "Last Dive"
    },
    "652": {
        name: "gs_ump_abyss",
        tag: "Scaffold"
    },
    "653": {
        name: "cu_usps_noir",
        tag: "Neo-Noir"
    },
    "654": {
        name: "aq_xm_leaf_fade",
        tag: "Seasons"
    },
    "655": {
        name: "aq_sawedoff_zander2",
        tag: "Zander"
    },
    "656": {
        name: "gs_ak_colony01_red",
        tag: "Orbit Mk01"
    },
    "657": {
        name: "cu_usps_blueprint",
        tag: "Blueprint"
    },
    "658": {
        name: "gs_dualberettas_cobra",
        tag: "Cobra Strike"
    },
    "659": {
        name: "sp_famas_macabre",
        tag: "Macabre"
    },
    "660": {
        name: "cu_fiveseven_hyperbeast",
        tag: "Hyper Beast"
    },
    "661": {
        name: "cu_galil_candychaos",
        tag: "Sugar Rush"
    },
    "662": {
        name: "cu_awp_hannya",
        tag: "Oni Taiji"
    },
    "663": {
        name: "cu_m4a1s_metritera",
        tag: "Briefing"
    },
    "664": {
        name: "cu_m4a4_hellfire",
        tag: "Hellfire"
    },
    "665": {
        name: "am_mac10_aloha",
        tag: "Aloha"
    },
    "666": {
        name: "am_mag7_caustic",
        tag: "Hard Water"
    },
    "667": {
        name: "cu_p2000_hunter",
        tag: "Woodsman"
    },
    "668": {
        name: "cu_p250_axiom",
        tag: "Red Rock"
    },
    "669": {
        name: "hy_p90_barebones_blue",
        tag: "Death Grip"
    },
    "670": {
        name: "cu_ssg08_deathshead",
        tag: "Death's Head"
    },
    "671": {
        name: "aq_tec9_chalk_pattern",
        tag: "Cut Out"
    },
    "672": {
        name: "aq_ump45_flameflower",
        tag: "Metal Flowers"
    },
    "673": {
        name: "aq_sawed-off_flower",
        tag: "Morris"
    },
    "674": {
        name: "cu_aug_orange_triangle",
        tag: "Triqua"
    },
    "675": {
        name: "gs_ak47_empress",
        tag: "The Empress"
    },
    "676": {
        name: "cu_bizon_all_in",
        tag: "High Roller"
    },
    "677": {
        name: "gs_g3sg1_cetme_redux",
        tag: "Hunter"
    },
    "678": {
        name: "cu_p250_cybercroc",
        tag: "See Ya Later"
    },
    "679": {
        name: "cu_mp9_goo",
        tag: "Goo"
    },
    "680": {
        name: "cu_glock_indigo",
        tag: "Off World"
    },
    "681": {
        name: "gs_m4a1_shatter",
        tag: "Leaded Glass"
    },
    "682": {
        name: "am_mac10_oceani",
        tag: "Oceanic"
    },
    "683": {
        name: "gs_r8_llamacannon",
        tag: "Llama Cannon"
    },
    "684": {
        name: "cu_tec9_cracked_opal",
        tag: "Cracked Opal"
    },
    "685": {
        name: "hy_scar20_jungle_slipstream",
        tag: "Jungle Slipstream"
    },
    "686": {
        name: "gs_sg553_phantom",
        tag: "Phantom"
    },
    "687": {
        name: "gs_cz75_tacticat",
        tag: "Tacticat"
    },
    "688": {
        name: "cu_ump45_x-ray_machine",
        tag: "Exposure"
    },
    "689": {
        name: "aq_xm1014_ziggy_anarchy",
        tag: "Ziggy"
    },
    "690": {
        name: "gs_aug_stymphalian_birds",
        tag: "Stymphalian"
    },
    "691": {
        name: "gs_awp_death",
        tag: "Mortis"
    },
    "692": {
        name: "cu_bizon_riot",
        tag: "Night Riot"
    },
    "693": {
        name: "gs_fiveseven_hot_rod_violet",
        tag: "Flame Test"
    },
    "694": {
        name: "aa_glock_18_urban_moon_fever",
        tag: "Moonrise"
    },
    "695": {
        name: "cu_m4a4_neo_noir",
        tag: "Neo-Noir"
    },
    "696": {
        name: "gs_mp7_bloodsport",
        tag: "Bloodsport"
    },
    "697": {
        name: "cu_mp9_black_sand",
        tag: "Black Sand"
    },
    "698": {
        name: "sp_negev_lionfish",
        tag: "Lionfish"
    },
    "699": {
        name: "gs_nova_anchorite",
        tag: "Wild Six"
    },
    "700": {
        name: "cu_p2000_urban_hazard",
        tag: "Urban Hazard"
    },
    "701": {
        name: "gs_revolver_tread",
        tag: "Grip"
    },
    "702": {
        name: "sp_sg533_aloha",
        tag: "Aloha"
    },
    "703": {
        name: "aq_mag7_swag7",
        tag: "SWAG-7"
    },
    "704": {
        name: "cu_ump45_white_fang",
        tag: "Arctic Wolf"
    },
    "705": {
        name: "cu_usp_cut",
        tag: "Cortex"
    },
    "706": {
        name: "cu_xm1014_oxide_blaze",
        tag: "Oxide Blaze"
    },
    "707": {
        name: "cu_ak_neon_rider",
        tag: "Neon Rider"
    },
    "708": {
        name: "hy_aug_torn_orange",
        tag: "Amber Slipstream"
    },
    "709": {
        name: "cu_cz75_eco",
        tag: "Eco"
    },
    "710": {
        name: "sp_elites_winter_raider",
        tag: "Shred"
    },
    "711": {
        name: "gs_deagle_aggressor",
        tag: "Code Red"
    },
    "712": {
        name: "gs_g3sg1_buccaneer",
        tag: "High Seas"
    },
    "713": {
        name: "gs_glock_thunder_dust",
        tag: "Warhawk"
    },
    "714": {
        name: "cu_m4a1s_nightmare",
        tag: "Nightmare"
    },
    "715": {
        name: "cu_mp9_vein",
        tag: "Capillary"
    },
    "716": {
        name: "cu_nova_toy_soldier",
        tag: "Toy Soldier"
    },
    "717": {
        name: "gs_p90_tread",
        tag: "Traction"
    },
    "718": {
        name: "am_awp_pawpaw",
        tag: "PAW"
    },
    "719": {
        name: "gs_powercore_mp7",
        tag: "Powercore"
    },
    "720": {
        name: "cu_sawedoff_devourer",
        tag: "Devourer"
    },
    "721": {
        name: "cu_r8_survivalist",
        tag: "Survivalist"
    },
    "722": {
        name: "cu_tec9_snake",
        tag: "Snek-9"
    },
    "723": {
        name: "cu_famas_owl_orange",
        tag: "Eye of Athena"
    },
    "724": {
        name: "cu_ak_island_floral",
        tag: "Wild Lotus"
    },
    "725": {
        name: "hy_bloom_red",
        tag: "Day Lily"
    },
    "726": {
        name: "sp_bloom_orange",
        tag: "Sunset Lily"
    },
    "727": {
        name: "am_bloom_blue",
        tag: "Midnight Lily"
    },
    "728": {
        name: "sp_bud_green",
        tag: "Teal Blossom"
    },
    "729": {
        name: "hy_bud_red",
        tag: "Crimson Blossom"
    },
    "730": {
        name: "sp_bud_blue",
        tag: "Dark Blossom"
    },
    "731": {
        name: "hy_leaf_green",
        tag: "Banana Leaf"
    },
    "732": {
        name: "hy_leaf_blue",
        tag: "Synth Leaf"
    },
    "733": {
        name: "sp_leaf_orange",
        tag: "Rust Leaf"
    },
    "734": {
        name: "cu_mp9_island_floral",
        tag: "Wild Lily"
    },
    "735": {
        name: "sp_nightstripe",
        tag: "Night Stripe"
    },
    "736": {
        name: "gs_awp_enamel",
        tag: "The Prince"
    },
    "737": {
        name: "gs_mag7_glass",
        tag: "Cinquedea"
    },
    "738": {
        name: "hy_murano_orange",
        tag: "Orange Murano"
    },
    "739": {
        name: "am_murano_violet",
        tag: "Violet Murano"
    },
    "740": {
        name: "hy_murano_blue",
        tag: "Navy Murano"
    },
    "741": {
        name: "am_ren_dark",
        tag: "Dark Filigree"
    },
    "742": {
        name: "am_ren_red",
        tag: "Red Filigree"
    },
    "743": {
        name: "hy_ren_orange",
        tag: "Orange Filigree"
    },
    "744": {
        name: "am_veneto_red",
        tag: "Baroque Red"
    },
    "745": {
        name: "hy_veneto_purple",
        tag: "Baroque Purple"
    },
    "746": {
        name: "am_veneto2",
        tag: "Baroque Orange"
    },
    "747": {
        name: "cu_dual_elites_rally",
        tag: "Twin Turbo"
    },
    "748": {
        name: "gs_mac10_checker",
        tag: "Calf Skin"
    },
    "749": {
        name: "gs_p250_checker",
        tag: "Vino Primo"
    },
    "750": {
        name: "cu_sg553_rally",
        tag: "Integrale"
    },
    "751": {
        name: "gs_ssg08_checker",
        tag: "Hand Brake"
    },
    "752": {
        name: "aa_fade_mp7",
        tag: "Fade"
    },
    "753": {
        name: "sp_tape_short_rally",
        tag: "Dirt Drop"
    },
    "754": {
        name: "aq_steel_inferno",
        tag: "Rust Coat"
    },
    "755": {
        name: "hy_splatter3",
        tag: "Slide"
    },
    "756": {
        name: "gs_awp_gungnir",
        tag: "Gungnir"
    },
    "757": {
        name: "am_jorm_green",
        tag: "Emerald Jörmungandr"
    },
    "758": {
        name: "am_jorm_orange",
        tag: "Flame Jörmungandr"
    },
    "759": {
        name: "am_jorm_blue",
        tag: "Astral Jörmungandr"
    },
    "760": {
        name: "am_knots_silver",
        tag: "Frost Borre"
    },
    "761": {
        name: "am_knots_brown",
        tag: "Copper Borre"
    },
    "762": {
        name: "so_rune_stone",
        tag: "Red Stone"
    },
    "763": {
        name: "gs_negev_thor",
        tag: "Mjölnir"
    },
    "764": {
        name: "gs_deagle_fennec",
        tag: "Fennec Fox"
    },
    "765": {
        name: "aa_desert_bloom_bright",
        tag: "Desert Blossom"
    },
    "775": {
        name: "hy_blueprint_white",
        tag: "Facility Sketch"
    },
    "776": {
        name: "hy_blueprint_aqua",
        tag: "Facility Negative"
    },
    "777": {
        name: "hy_blueprint_red",
        tag: "Facility Draft"
    },
    "778": {
        name: "hy_blueprint_bluered",
        tag: "Facility Dark"
    },
    "779": {
        name: "am_circuitboard_orange",
        tag: "Random Access"
    },
    "780": {
        name: "am_circuitboard_silver",
        tag: "Mainframe"
    },
    "781": {
        name: "am_circuitboard_aqua",
        tag: "Co-Processor"
    },
    "782": {
        name: "am_circuitboard_green",
        tag: "Motherboard"
    },
    "783": {
        name: "hy_ducts_yellow",
        tag: "Bulkhead"
    },
    "784": {
        name: "hy_ducts_green",
        tag: "Coolant"
    },
    "785": {
        name: "hy_ducts_grey",
        tag: "Mandrel"
    },
    "786": {
        name: "hy_ducts_blue",
        tag: "Exchanger"
    },
    "787": {
        name: "hy_nuclear_hotorange",
        tag: "Core Breach"
    },
    "788": {
        name: "hy_nuclear_skulls_redblue",
        tag: "Acheron"
    },
    "789": {
        name: "am_nuclear_skulls_green",
        tag: "Nuclear Garden"
    },
    "790": {
        name: "hy_nuclear_skulls_aqua",
        tag: "Cold Fusion"
    },
    "791": {
        name: "gs_tec9_envoy",
        tag: "Remote Control"
    },
    "792": {
        name: "gs_m4a1s_operator",
        tag: "Control Panel"
    },
    "793": {
        name: "hy_red_hex",
        tag: "Converter"
    },
    "794": {
        name: "sp_mesh_safetyblack",
        tag: "Sweeper"
    },
    "795": {
        name: "hy_mesh_safetyorange",
        tag: "Safety Net"
    },
    "796": {
        name: "sp_mesh_safetyred",
        tag: "Check Engine"
    },
    "797": {
        name: "aa_vertigo_red",
        tag: "Brake Light"
    },
    "798": {
        name: "so_orange_accents3",
        tag: "Nitro"
    },
    "799": {
        name: "aa_vertigo_blue",
        tag: "High Beam"
    },
    "800": {
        name: "hy_labrat_mp5",
        tag: "Lab Rats"
    },
    "801": {
        name: "cu_ak47_asiimov",
        tag: "Asiimov"
    },
    "802": {
        name: "cu_ump_arrows",
        tag: "Momentum"
    },
    "803": {
        name: "cu_awp_neonoir",
        tag: "Neo-Noir"
    },
    "804": {
        name: "gs_mp9_colony01",
        tag: "Modest Threat"
    },
    "805": {
        name: "gs_deagle_mecha",
        tag: "Mecha Industries"
    },
    "806": {
        name: "gs_g3sg1_savage",
        tag: "Scavenger"
    },
    "807": {
        name: "hy_galil_signal_red",
        tag: "Signal"
    },
    "808": {
        name: "cu_glock18_corroden",
        tag: "Oxide Blaze"
    },
    "809": {
        name: "gs_nova_hunter_brute",
        tag: "Wood Fired"
    },
    "810": {
        name: "gs_mp5_festival_drip",
        tag: "Phosphor"
    },
    "811": {
        name: "gs_m4a4_chopper_ghost",
        tag: "Magnesium"
    },
    "812": {
        name: "gs_mac10_exo_pipes",
        tag: "Pipe Down"
    },
    "813": {
        name: "aa_p250_gravediggers",
        tag: "Nevermore"
    },
    "814": {
        name: "cu_sawedoff_black_sand",
        tag: "Black Sand"
    },
    "815": {
        name: "gs_sg553_over_heated",
        tag: "Danger Close"
    },
    "816": {
        name: "gs_tec9_fubar",
        tag: "Fubar"
    },
    "817": {
        name: "cu_usp_flashback",
        tag: "Flashback"
    },
    "818": {
        name: "am_ddpat_purple",
        tag: "Purple DDPAT"
    },
    "819": {
        name: "gs_awp_hydra",
        tag: "Desert Hydra"
    },
    "820": {
        name: "am_mirage_flowers_metalic",
        tag: "Music Box"
    },
    "821": {
        name: "am_moro_textile_bright",
        tag: "Elegant Vines"
    },
    "822": {
        name: "am_navy_shine",
        tag: "Navy Sheen"
    },
    "823": {
        name: "gs_aug_sand_storm",
        tag: "Sand Storm"
    },
    "824": {
        name: "sp_dry_wood",
        tag: "Drift Wood"
    },
    "825": {
        name: "sp_desert_skulls_dawn",
        tag: "Drought"
    },
    "826": {
        name: "sp_mirage_flowers_tan",
        tag: "Sienna Damask"
    },
    "827": {
        name: "sp_moro_carving_burnt",
        tag: "Humidor"
    },
    "828": {
        name: "sp_moro_textile_green_vine",
        tag: "Verdant Growth"
    },
    "829": {
        name: "hy_lizard_skin",
        tag: "Anolis"
    },
    "835": {
        name: "sp_famas_ghost_insects",
        tag: "Crypsis"
    },
    "836": {
        name: "cu_ak47_aztec",
        tag: "Uncharted"
    },
    "837": {
        name: "cu_five_seven_angry",
        tag: "Angry Mob"
    },
    "838": {
        name: "cu_awp_viper",
        tag: "Atheris"
    },
    "839": {
        name: "cu_tec9_bamboo",
        tag: "Bamboozle"
    },
    "840": {
        name: "gs_mac10_fish_bait",
        tag: "Whitefish"
    },
    "841": {
        name: "gs_deagle_exo",
        tag: "Light Rail"
    },
    "842": {
        name: "sp_galil_akoben",
        tag: "Akoben"
    },
    "843": {
        name: "cu_revolver_oppressor",
        tag: "Skull Crusher"
    },
    "844": {
        name: "gs_m4a4_emperor",
        tag: "The Emperor"
    },
    "845": {
        name: "cu_aug_momentum",
        tag: "Momentum"
    },
    "846": {
        name: "gs_mp5sd_astromatic",
        tag: "Gauss"
    },
    "847": {
        name: "cu_mp7_racketeer",
        tag: "Mischief"
    },
    "848": {
        name: "aq_p250_verdigris",
        tag: "Verdigris"
    },
    "849": {
        name: "cu_p90_offworld",
        tag: "Off World"
    },
    "850": {
        name: "cu_xm1014_incinerator",
        tag: "Incinegator"
    },
    "851": {
        name: "aa_ump45_moonrise_sunset",
        tag: "Moonrise"
    },
    "852": {
        name: "am_doppler_phase1_widow",
        tag: "Doppler"
    },
    "853": {
        name: "am_doppler_phase2_widow",
        tag: "Doppler"
    },
    "854": {
        name: "am_doppler_phase3_widow",
        tag: "Doppler"
    },
    "855": {
        name: "am_doppler_phase4_widow",
        tag: "Doppler"
    },
    "856": {
        name: "am_marble_fade_widow",
        tag: "Marble Fade"
    },
    "857": {
        name: "aq_damascus_prisma",
        tag: "Damascus Steel"
    },
    "858": {
        name: "aq_damascus_widow",
        tag: "Damascus Steel"
    },
    "859": {
        name: "am_crystallized_green",
        tag: "Emerald Quartz"
    },
    "860": {
        name: "hy_gelpen_dark",
        tag: "Pyre"
    },
    "861": {
        name: "sp_asgard_wall",
        tag: "Barricade"
    },
    "862": {
        name: "am_crystallized_dark_green",
        tag: "Moss Quartz"
    },
    "863": {
        name: "sp_knots_blue",
        tag: "Night Borre"
    },
    "864": {
        name: "so_red_sg553",
        tag: "Candy Apple"
    },
    "865": {
        name: "hy_canals_tile",
        tag: "Stone Mosaico"
    },
    "866": {
        name: "sp_spray_water",
        tag: "Canal Spray"
    },
    "867": {
        name: "am_stained_glass",
        tag: "Stained Glass"
    },
    "868": {
        name: "hy_flowers_stmarc",
        tag: "Sea Calico"
    },
    "869": {
        name: "sp_palm_sunset",
        tag: "Sundown"
    },
    "870": {
        name: "sp_palm_green",
        tag: "Jungle Thicket"
    },
    "871": {
        name: "sp_twigs_beach",
        tag: "Surfwood"
    },
    "872": {
        name: "hy_bamboo_stmarc",
        tag: "Bamboo Garden"
    },
    "873": {
        name: "so_aqua_stmarc",
        tag: "Seabird"
    },
    "879": {
        name: "aa_fade_ump",
        tag: "Fade"
    },
    "880": {
        name: "hy_desert_bloom",
        tag: "Parched"
    },
    "884": {
        name: "cu_bizon_road_warrior",
        tag: "Embargo"
    },
    "885": {
        name: "gs_ak47_nibbler",
        tag: "Rat Rod"
    },
    "886": {
        name: "cu_aug_whitefang",
        tag: "Arctic Wolf"
    },
    "887": {
        name: "cu_awp_virus",
        tag: "Containment Breach"
    },
    "888": {
        name: "gs_mp5_etch",
        tag: "Acid Wash"
    },
    "889": {
        name: "gs_tec9_decimator",
        tag: "Decimator"
    },
    "890": {
        name: "cu_nova_featherswing",
        tag: "Plume"
    },
    "891": {
        name: "cu_g3sg1_blacksand",
        tag: "Black Sand"
    },
    "892": {
        name: "gs_r8_memento",
        tag: "Memento"
    },
    "893": {
        name: "cu_mp7_replica",
        tag: "Neon Ply"
    },
    "894": {
        name: "cu_p2000_obsidian",
        tag: "Obsidian"
    },
    "895": {
        name: "gs_dual_elites_rose",
        tag: "Balance"
    },
    "896": {
        name: "sp_scar20_striker_dust",
        tag: "Torn"
    },
    "897": {
        name: "cu_sg553_reactor",
        tag: "Colony IV"
    },
    "898": {
        name: "gs_mac10_stalker",
        tag: "Stalker"
    },
    "899": {
        name: "cu_ssg08_tickler",
        tag: "Bloodshot"
    },
    "900": {
        name: "gs_m249_warbird_veteran",
        tag: "Warbird"
    },
    "902": {
        name: "aq_m249_aztec",
        tag: "Aztec"
    },
    "903": {
        name: "gs_dual_elites_classic",
        tag: "Elite 1.6"
    },
    "904": {
        name: "cu_famas_nuke_tension",
        tag: "Decommissioned"
    },
    "905": {
        name: "cu_tec9_flash",
        tag: "Flash Out"
    },
    "906": {
        name: "cu_fiveseven_gsg9",
        tag: "Buddy"
    },
    "907": {
        name: "gs_p250_inferno",
        tag: "Inferno"
    },
    "908": {
        name: "gs_mac10_dust_crate",
        tag: "Classic Crate"
    },
    "909": {
        name: "gs_mag7_popdog",
        tag: "Popdog"
    },
    "910": {
        name: "cu_mp9_hydra",
        tag: "Hydra"
    },
    "911": {
        name: "cu_p90_nostalgia",
        tag: "Nostalgia"
    },
    "913": {
        name: "am_aug_death_by_doggy",
        tag: "Death by Puppy"
    },
    "914": {
        name: "cu_scar_assault",
        tag: "Assault"
    },
    "915": {
        name: "gs_mp5_fbi",
        tag: "Agent"
    },
    "916": {
        name: "cu_ump_bomb",
        tag: "Plastique"
    },
    "917": {
        name: "cu_awp_wildfire",
        tag: "Wildfire"
    },
    "918": {
        name: "cu_glock_hero",
        tag: "Sacrifice"
    },
    "919": {
        name: "gs_famas_legacy_gold",
        tag: "Commemoration"
    },
    "920": {
        name: "hy_veneto_tan",
        tag: "Boroque Sand"
    },
    "921": {
        name: "gs_ak47_gold_arabesque",
        tag: "Gold Arabesque"
    },
    "922": {
        name: "am_lizard_red",
        tag: "Orange Anolis"
    },
    "923": {
        name: "gs_mp5_neon_flektarn",
        tag: "Oxide Oasis"
    },
    "924": {
        name: "hy_brush_camo_tan",
        tag: "Desert Brush"
    },
    "925": {
        name: "hy_ddpat_desert",
        tag: "Desert DDPAT"
    },
    "926": {
        name: "hy_ddpat_urban_red",
        tag: "Red DDPAT"
    },
    "927": {
        name: "hy_dry_wood",
        tag: "Spalted Wood"
    },
    "928": {
        name: "hy_desert_multicam",
        tag: "Black & Tan"
    },
    "929": {
        name: "hy_torn_camo_paints",
        tag: "Quick Sand"
    },
    "930": {
        name: "sp_moro_carving_lightblue",
        tag: "New Roots"
    },
    "931": {
        name: "sp_moro_carving_yellow",
        tag: "Old Roots"
    },
    "932": {
        name: "sp_moro_textile_purple_yellow",
        tag: "Withered Vine"
    },
    "933": {
        name: "sp_palm_night",
        tag: "Midnight Palm"
    },
    "934": {
        name: "sp_desert_skulls",
        tag: "Bleached"
    },
    "935": {
        name: "sp_zebracam_red",
        tag: "Prey"
    },
    "941": {
        name: "cu_ak-47_phantom_disruptor",
        tag: "Phantom Disruptor"
    },
    "942": {
        name: "gs_aug_thunderstorm",
        tag: "Tom Cat"
    },
    "943": {
        name: "cu_awp_vein",
        tag: "Capillary"
    },
    "944": {
        name: "cu_cz75_cerakote",
        tag: "Distressed"
    },
    "945": {
        name: "cu_deagle_replica",
        tag: "Blue Ply"
    },
    "946": {
        name: "cu_m4a1s_csgo2048",
        tag: "Player Two"
    },
    "947": {
        name: "cu_mac10_nacre",
        tag: "Disco Tech"
    },
    "948": {
        name: "gs_mag7_justice",
        tag: "Justice"
    },
    "949": {
        name: "cu_mp5_desert_strike",
        tag: "Desert Strike"
    },
    "950": {
        name: "cu_negev_prototype",
        tag: "Prototype"
    },
    "951": {
        name: "aq_p2000_acid_clover",
        tag: "Acid Etched"
    },
    "952": {
        name: "gs_r8_leviathan",
        tag: "Bone Forged"
    },
    "953": {
        name: "cu_sawedoff_apocalypto",
        tag: "Apocalypto"
    },
    "954": {
        name: "gs_scar20_enforcer",
        tag: "Enforcer"
    },
    "955": {
        name: "cu_sg553_darkwing",
        tag: "Darkwing"
    },
    "956": {
        name: "cu_ssg08_fever_dream",
        tag: "Fever Dream"
    },
    "957": {
        name: "cu_glock18_warmaiden",
        tag: "Bullet Queen"
    },
    "958": {
        name: "cu_negev_ultralight",
        tag: "Ultralight"
    },
    "959": {
        name: "cu_ak47_anubis",
        tag: "Legion of Anubis"
    },
    "960": {
        name: "aq_p2000_lost_world",
        tag: "Gnarled"
    },
    "961": {
        name: "cu_mag7_monster_call",
        tag: "Monster Call"
    },
    "962": {
        name: "cu_deag_printstream",
        tag: "Printstream"
    },
    "963": {
        name: "cu_glock_eyecontact",
        tag: "Vogue"
    },
    "964": {
        name: "gs_tec9_guerilla",
        tag: "Brother"
    },
    "965": {
        name: "cu_mac10_isoonna",
        tag: "Allure"
    },
    "966": {
        name: "gs_sg553_rusty",
        tag: "Ol' Rusty"
    },
    "967": {
        name: "cu_ssg08_mainframe",
        tag: "Mainframe 001"
    },
    "968": {
        name: "cu_p250_cassette",
        tag: "Cassette"
    },
    "969": {
        name: "gs_p90_container",
        tag: "Freight"
    },
    "970": {
        name: "cu_xm1014_amulet_blue",
        tag: "Entombed"
    },
    "971": {
        name: "cu_m4a4_queenfairy",
        tag: "Tooth Fairy"
    },
    "972": {
        name: "gs_galil_phoenix",
        tag: "Connexion"
    },
    "973": {
        name: "gs_bizon_hellraider",
        tag: "Runic"
    },
    "974": {
        name: "gs_mp5sd_wasteland_legacy",
        tag: "Kitbash"
    },
    "975": {
        name: "gs_awp_exoskeleton",
        tag: "Exoskeleton"
    },
    "976": {
        name: "gs_cz75_vendetta",
        tag: "Vendetta"
    },
    "977": {
        name: "hy_p90_dino_rampage",
        tag: "Cocoa Rampage"
    },
    "978": {
        name: "gs_dual_elites_dezastre",
        tag: "Dezastre"
    },
    "979": {
        name: "cu_five_seven_diary",
        tag: "Fairy Tale"
    },
    "980": {
        name: "gs_g3sg1_disrupt",
        tag: "Digital Mesh"
    },
    "981": {
        name: "gs_galil_vandal",
        tag: "Vandal"
    },
    "982": {
        name: "cu_p250_infect",
        tag: "Contaminant"
    },
    "983": {
        name: "cu_m249_deep_relief",
        tag: "Deep Relief"
    },
    "984": {
        name: "cu_m4a1s_printstream",
        tag: "Printstream"
    },
    "985": {
        name: "cu_m4a4_cyberpunk",
        tag: "Cyber Security"
    },
    "986": {
        name: "gs_mp5_conditionzero",
        tag: "Condition Zero"
    },
    "987": {
        name: "cu_nova_polymer",
        tag: "Clear Polymer"
    },
    "988": {
        name: "cu_glock_noir",
        tag: "Neo-Noir"
    },
    "989": {
        name: "cu_ssg08_chromatic",
        tag: "Parallax"
    },
    "990": {
        name: "gs_ump_gold_bismuth",
        tag: "Gold Bismuth"
    },
    "991": {
        name: "cu_usp_krokos",
        tag: "Monster Mashup"
    },
    "992": {
        name: "am_numbers_bronze",
        tag: "The Bronze"
    },
    "993": {
        name: "cu_csgo_camo",
        tag: "Global Offensive"
    },
    "994": {
        name: "am_authority_brown",
        tag: "Charter"
    },
    "995": {
        name: "am_intelligence_grey",
        tag: "Surveillance"
    },
    "996": {
        name: "am_intelligence_orange",
        tag: "Threat Detected"
    },
    "997": {
        name: "am_numbers_red_blue",
        tag: "Dispatch"
    },
    "998": {
        name: "hy_numbers_green",
        tag: "Switch Board"
    },
    "999": {
        name: "am_numbers_magenta",
        tag: "Prime Conspiracy"
    },
    "1000": {
        name: "cu_jaguar_p90",
        tag: "Run and Hide"
    },
    "1001": {
        name: "cu_m4a1_snake",
        tag: "Welcome to the Jungle"
    },
    "1002": {
        name: "aa_fade_red_blue",
        tag: "Berries And Cherries"
    },
    "1003": {
        name: "cu_ump_crime_scene",
        tag: "Crime Scene"
    },
    "1004": {
        name: "cu_ak_xray",
        tag: "X-Ray"
    },
    "1005": {
        name: "am_heist_plans_green",
        tag: "Heist"
    },
    "1006": {
        name: "am_heist_plans_purple",
        tag: "Night Heist"
    },
    "1007": {
        name: "am_heist_plans_yellow",
        tag: "Vault Heist"
    },
    "1008": {
        name: "hy_houndstooth_brown",
        tag: "Houndstooth"
    },
    "1009": {
        name: "gs_mac10_snake",
        tag: "Hot Snakes"
    },
    "1010": {
        name: "hy_phoenix_tags_lilac",
        tag: "Phoenix Chalk"
    },
    "1011": {
        name: "am_phoenix_tags_blue",
        tag: "Phoenix Marker"
    },
    "1012": {
        name: "hy_phoenix_tags_red",
        tag: "Phoenix Stencil"
    },
    "1013": {
        name: "sp_phoenix_tags_purple",
        tag: "Phoenix Blacklight"
    },
    "1014": {
        name: "hy_tigers_tan",
        tag: "Clay Ambush"
    },
    "1015": {
        name: "am_tigers_brown",
        tag: "Tiger Pit"
    },
    "1016": {
        name: "cu_money_glock",
        tag: "Franklin"
    },
    "1017": {
        name: "am_m4a1s_bluesmoke",
        tag: "Blue Phosphor"
    },
    "1018": {
        name: "cu_ak_jaguar",
        tag: "Panthera onca"
    },
    "1019": {
        name: "am_black_panther",
        tag: "Panther Camo"
    },
    "1020": {
        name: "aa_ancient_brown",
        tag: "Ancient Earth"
    },
    "1021": {
        name: "am_ancient_warm",
        tag: "Ancient Lore"
    },
    "1022": {
        name: "aa_ruins_green",
        tag: "Lush Ruins"
    },
    "1023": {
        name: "hy_drywood_green",
        tag: "Tall Grass"
    },
    "1024": {
        name: "hy_ancient_tiles_peach",
        tag: "Blast From the Past"
    },
    "1025": {
        name: "am_gold_brick",
        tag: "Gold Brick"
    },
    "1026": {
        name: "aa_awp_fade",
        tag: "Fade"
    },
    "1027": {
        name: "am_intelligence_magenta",
        tag: "Target Acquired"
    },
    "1028": {
        name: "hy_authority_purple",
        tag: "Magna Carta"
    },
    "1029": {
        name: "am_tigers_blue",
        tag: "Silk Tiger"
    },
    "1030": {
        name: "hy_p250_tiger",
        tag: "Bengal Tiger"
    },
    "1031": {
        name: "sp_ancient_bright",
        tag: "Ancient Visions"
    },
    "1032": {
        name: "hy_ruins_red",
        tag: "Dusk Ruins"
    },
    "1033": {
        name: "am_jade",
        tag: "Carved Jade"
    },
    "1034": {
        name: "am_ancient_wine",
        tag: "Ancient Ritual"
    },
    "1035": {
        name: "gs_ak47_professional",
        tag: "Slate"
    },
    "1036": {
        name: "cu_cz75_whirlwind",
        tag: "Circaetus"
    },
    "1037": {
        name: "cu_mp9_food_chain",
        tag: "Food Chain"
    },
    "1038": {
        name: "cu_galil_chroma_pink",
        tag: "Chromatic Aberration"
    },
    "1039": {
        name: "gs_glock_polymer",
        tag: "Clear Polymer"
    },
    "1040": {
        name: "gs_usps_hangedman",
        tag: "The Traitor"
    },
    "1041": {
        name: "cu_m4a4_love",
        tag: "In Living Color"
    },
    "1042": {
        name: "gs_m249_combine",
        tag: "O.S.I.P.R."
    },
    "1043": {
        name: "cu_negev_devtexture",
        tag: "dev_texture"
    },
    "1044": {
        name: "gs_p250_cybershell",
        tag: "Cyber Shell"
    },
    "1045": {
        name: "cu_mac10_portable",
        tag: "Button Masher"
    },
    "1046": {
        name: "aq_xm1014_punk",
        tag: "XOXO"
    },
    "1047": {
        name: "gs_r8_rustking",
        tag: "Junk Yard"
    },
    "1048": {
        name: "gs_sg553_deathmetal",
        tag: "Heavy Metal"
    },
    "1049": {
        name: "am_ump45_electrowave",
        tag: "Oscillator"
    },
    "1050": {
        name: "cu_deag_trigger_discipline",
        tag: "Trigger Discipline"
    },
    "1051": {
        name: "sp_nova_wind_dispersal",
        tag: "Windblown"
    },
    "1052": {
        name: "cu_ssg08_scorpion",
        tag: "Death Strike"
    },
    "1053": {
        name: "am_nuclear_pattern4_famas",
        tag: "Meltdown"
    },
    "1055": {
        name: "aa_spacerace_orange",
        tag: "Space Race"
    },
    "1056": {
        name: "sp_spacerace_blue",
        tag: "Sputnik"
    },
    "1058": {
        name: "hy_technowar_rwb",
        tag: "POP AWP"
    },
    "1059": {
        name: "sp_technowar_red",
        tag: "Fizzy POP"
    },
    "1060": {
        name: "hy_trainarchitect_green",
        tag: "Spring Twilly"
    },
    "1061": {
        name: "hy_trainarchitect",
        tag: "Autumn Twilly"
    },
    "1063": {
        name: "gs_m4a4_coalition",
        tag: "The Coalition"
    },
    "1064": {
        name: "gs_train_cz75",
        tag: "Syndicate"
    },
    "1065": {
        name: "so_whiteout_riptide",
        tag: "Whiteout"
    },
    "1066": {
        name: "aa_wiring_yellow",
        tag: "Faulty Wiring"
    },
    "1067": {
        name: "cu_mac10_propaganda",
        tag: "Propaganda"
    },
    "1070": {
        name: "hy_ak47lam_green",
        tag: "Green Laminate"
    },
    "1071": {
        name: "sp_galil_caution",
        tag: "CAUTION!"
    },
    "1072": {
        name: "hy_geometric_steps_pearl",
        tag: "Prism Terrace"
    },
    "1073": {
        name: "gs_m4a1_vertigo",
        tag: "Imminent Danger"
    },
    "1074": {
        name: "hy_vertigogeo",
        tag: "Schematic"
    },
    "1075": {
        name: "hy_vertigospray_blue",
        tag: "Strats"
    },
    "1076": {
        name: "hy_vertigoillusion",
        tag: "Framework"
    },
    "1077": {
        name: "hy_vertigoillusion_yellow",
        tag: "Interlock"
    },
    "1078": {
        name: "sp_tire_tread_blue",
        tag: "Blue Tire"
    },
    "1079": {
        name: "sp_tire_tread_red",
        tag: "Red Tire"
    },
    "1080": {
        name: "hy_vertigospray",
        tag: "Infrastructure"
    },
    "1081": {
        name: "aa_vertigogeo_neon",
        tag: "Digital Architect"
    },
    "1082": {
        name: "cu_vertigo_fiveseven",
        tag: "Fall Hazard"
    },
    "1083": {
        name: "aa_wiring",
        tag: "Breaker Box"
    },
    "1084": {
        name: "cu_sg553_caution",
        tag: "Hazard Pay"
    },
    "1085": {
        name: "aa_engine_performance",
        tag: "Mechanism"
    },
    "1086": {
        name: "sp_engine_dirty",
        tag: "Oil Change"
    },
    "1087": {
        name: "gs_ak47_abstract",
        tag: "Leet Museo"
    },
    "1088": {
        name: "gs_aug_plague",
        tag: "Plague"
    },
    "1089": {
        name: "gs_mag7_bismuth",
        tag: "BI83 Spectrum"
    },
    "1090": {
        name: "cu_deagle_kitch",
        tag: "Ocean Drive"
    },
    "1091": {
        name: "gs_dual_berettas_tread",
        tag: "Tread"
    },
    "1092": {
        name: "cu_famas_spectron",
        tag: "ZX Spectron"
    },
    "1093": {
        name: "gs_five_seven_efusion",
        tag: "Boost Protocol"
    },
    "1094": {
        name: "aa_mp9_fuji_pink",
        tag: "Mount Fuji"
    },
    "1095": {
        name: "cu_g3sg1_tacticalmap",
        tag: "Keeping Tabs"
    },
    "1096": {
        name: "cu_mp7_khaki",
        tag: "Guerrilla"
    },
    "1097": {
        name: "gs_m4_flowers",
        tag: "Spider Lily"
    },
    "1098": {
        name: "cu_mac10_toybox",
        tag: "Toybox"
    },
    "1099": {
        name: "gs_bizon_flasher",
        tag: "Lumen"
    },
    "1100": {
        name: "cu_glock_snackattack",
        tag: "Snack Attack"
    },
    "1101": {
        name: "cu_ssg_overtake",
        tag: "Turbo Peek"
    },
    "1102": {
        name: "cu_usp_black_lotus",
        tag: "Black Lotus"
    },
    "1103": {
        name: "gs_xm1014_watchdog",
        tag: "Watchdog"
    },
    "1104": {
        name: "cu_bowie_lore",
        tag: "Lore"
    },
    "1105": {
        name: "cu_butterfly_lore",
        tag: "Lore"
    },
    "1106": {
        name: "cu_falchion_lore",
        tag: "Lore"
    },
    "1107": {
        name: "cu_huntsman_lore",
        tag: "Lore"
    },
    "1108": {
        name: "cu_push_lore",
        tag: "Lore"
    },
    "1109": {
        name: "gs_bowie_black_laminate",
        tag: "Black Laminate"
    },
    "1110": {
        name: "gs_butterfly_black_laminate",
        tag: "Black Laminate"
    },
    "1111": {
        name: "gs_falchion_black_laminate",
        tag: "Black Laminate"
    },
    "1112": {
        name: "gs_huntsman_black_laminate",
        tag: "Black Laminate"
    },
    "1113": {
        name: "gs_push_black_laminate",
        tag: "Black Laminate"
    },
    "1114": {
        name: "gs_bowie_autotronic",
        tag: "Autotronic"
    },
    "1115": {
        name: "gs_butterfly_autotronic",
        tag: "Autotronic"
    },
    "1116": {
        name: "gs_falchion_autotronic",
        tag: "Autotronic"
    },
    "1117": {
        name: "gs_huntsman_autotronic",
        tag: "Autotronic"
    },
    "1118": {
        name: "gs_push_autotronic",
        tag: "Autotronic"
    },
    "1119": {
        name: "am_emerald_marbleized_glock",
        tag: "Gamma Doppler"
    },
    "1120": {
        name: "am_gamma_doppler_phase1_glock",
        tag: "Gamma Doppler"
    },
    "1121": {
        name: "am_gamma_doppler_phase2_glock",
        tag: "Gamma Doppler"
    },
    "1122": {
        name: "am_gamma_doppler_phase3_glock",
        tag: "Gamma Doppler"
    },
    "1123": {
        name: "am_gamma_doppler_phase4_glock",
        tag: "Gamma Doppler"
    },
    "1125": {
        name: "cu_bizon_spacecat",
        tag: "Space Cat"
    },
    "1126": {
        name: "cu_elites_beware",
        tag: "Melondrama"
    },
    "1127": {
        name: "gs_famas_rapid_eyes",
        tag: "Rapid Eye Movement"
    },
    "1128": {
        name: "cu_fiveseven_alpha_omega",
        tag: "Scrawl"
    },
    "1129": {
        name: "cu_g3sg1_glade",
        tag: "Dream Glade"
    },
    "1130": {
        name: "gs_m4a1s_insomnia",
        tag: "Night Terror"
    },
    "1131": {
        name: "cu_mac10_pixie",
        tag: "Ensnared"
    },
    "1132": {
        name: "cu_mag7_predictor",
        tag: "Foresight"
    },
    "1133": {
        name: "cu_mp7_fear",
        tag: "Abyssal Apparition"
    },
    "1134": {
        name: "gs_mp9_starlight",
        tag: "Starlight Protector"
    },
    "1135": {
        name: "am_xm_zombie_offensive",
        tag: "Zombie Offensive"
    },
    "1136": {
        name: "cu_usp_to_hell",
        tag: "Ticket to Hell"
    },
    "1137": {
        name: "gs_mp5_kid_necronomicon",
        tag: "Necro Jr."
    },
    "1138": {
        name: "cu_p2k_flying_dream",
        tag: "Lifted Spirits"
    },
    "1139": {
        name: "sp_scar_chickenfight",
        tag: "Poultrygeist"
    },
    "1140": {
        name: "cu_sawedoff_ouija",
        tag: "Spirit Board"
    },
    "1141": {
        name: "cu_ak47_nightwish",
        tag: "Nightwish"
    },
    "1142": {
        name: "cu_usp_printstream",
        tag: "Printstream"
    },
    "1143": {
        name: "cu_ak47_cogthings",
        tag: "Ice Coaled"
    },
    "1144": {
        name: "cu_awp_chroma_pink",
        tag: "Chromatic Aberration"
    },
    "1145": {
        name: "gs_revolver_purple_elite",
        tag: "Crazy 8"
    },
    "1146": {
        name: "gs_famas_corp_meow",
        tag: "Meow 36"
    },
    "1147": {
        name: "cu_galil_destroyer",
        tag: "Destroyer"
    },
    "1148": {
        name: "cu_m249_downvote",
        tag: "Downtown"
    },
    "1149": {
        name: "cu_m4a4_elite_tactical",
        tag: "Poly Mag"
    },
    "1150": {
        name: "cu_mac10_monkeyflage",
        tag: "Monkeyflage"
    },
    "1151": {
        name: "cu_sg553_cyber_dragon",
        tag: "Dragon Tech"
    },
    "1152": {
        name: "cu_negev_clear_sky",
        tag: "Drop Me"
    },
    "1153": {
        name: "gs_p250_visions",
        tag: "Visions"
    },
    "1154": {
        name: "gs_p90_tangled",
        tag: "Vent Rush"
    },
    "1155": {
        name: "cu_sawedoff_kisslove",
        tag: "Kiss♥Love"
    },
    "1156": {
        name: "cu_dual_elites_evil_flora",
        tag: "Flora Carnivora"
    },
    "1157": {
        name: "gs_ump_roadblock",
        tag: "Roadblock"
    },
    "1158": {
        name: "gs_glock_elite_camo",
        tag: "Winterized"
    },
    "10006": {
        name: "bloodhound_black_silver",
        tag: "Charred"
    },
    "10007": {
        name: "bloodhound_snakeskin_brass",
        tag: "Snakebite"
    },
    "10008": {
        name: "bloodhound_metallic",
        tag: "Bronzed"
    },
    "10009": {
        name: "handwrap_leathery",
        tag: "Leather"
    },
    "10010": {
        name: "handwrap_camo_grey",
        tag: "Spruce DDPAT"
    },
    "10013": {
        name: "slick_black",
        tag: "Lunar Weave"
    },
    "10015": {
        name: "slick_military",
        tag: "Convoy"
    },
    "10016": {
        name: "slick_red",
        tag: "Crimson Weave"
    },
    "10018": {
        name: "sporty_light_blue",
        tag: "Superconductor"
    },
    "10019": {
        name: "sporty_military",
        tag: "Arid"
    },
    "10021": {
        name: "handwrap_red_slaughter",
        tag: "Slaughter"
    },
    "10024": {
        name: "motorcycle_basic_black",
        tag: "Eclipse"
    },
    "10026": {
        name: "motorcycle_mint_triangle",
        tag: "Spearmint"
    },
    "10027": {
        name: "motorcycle_mono_boom",
        tag: "Boom!"
    },
    "10028": {
        name: "motorcycle_triangle_blue",
        tag: "Cool Mint"
    },
    "10030": {
        name: "specialist_ddpat_green_camo",
        tag: "Forest DDPAT"
    },
    "10033": {
        name: "specialist_kimono_diamonds_red",
        tag: "Crimson Kimono"
    },
    "10034": {
        name: "specialist_emerald_web",
        tag: "Emerald Web"
    },
    "10035": {
        name: "specialist_orange_white",
        tag: "Foundation"
    },
    "10036": {
        name: "handwrap_fabric_orange_camo",
        tag: "Badlands"
    },
    "10037": {
        name: "sporty_purple",
        tag: "Pandora's Box"
    },
    "10038": {
        name: "sporty_green",
        tag: "Hedge Maze"
    },
    "10039": {
        name: "bloodhound_guerrilla",
        tag: "Guerrilla"
    },
    "10040": {
        name: "slick_snakeskin_yellow",
        tag: "Diamondback"
    },
    "10041": {
        name: "slick_snakeskin_white",
        tag: "King Snake"
    },
    "10042": {
        name: "slick_plaid_purple",
        tag: "Imperial Plaid"
    },
    "10043": {
        name: "slick_stitched_black_orange",
        tag: "Overtake"
    },
    "10044": {
        name: "slick_stitched_green_grey",
        tag: "Racing Green"
    },
    "10045": {
        name: "sporty_poison_frog_blue_white",
        tag: "Amphibious"
    },
    "10046": {
        name: "sporty_poison_frog_red_green",
        tag: "Bronze Morph"
    },
    "10047": {
        name: "sporty_black_webbing_yellow",
        tag: "Omega"
    },
    "10048": {
        name: "sporty_blue_pink",
        tag: "Vice"
    },
    "10049": {
        name: "motorcycle_choco_boom",
        tag: "POW!"
    },
    "10050": {
        name: "motorcycle_basic_green_orange",
        tag: "Turtle"
    },
    "10051": {
        name: "motorcycle_yellow_camo",
        tag: "Transport"
    },
    "10052": {
        name: "motorcycle_trigrid_blue",
        tag: "Polygon"
    },
    "10053": {
        name: "handwrap_leathery_fabric_blue_skulls",
        tag: "Cobalt Skulls"
    },
    "10054": {
        name: "handwrap_leathery_fabric_geometric_blue",
        tag: "Overprint"
    },
    "10055": {
        name: "handwrap_leathery_ducttape",
        tag: "Duct Tape"
    },
    "10056": {
        name: "handwrap_leathery_fabric_green_camo",
        tag: "Arboreal"
    },
    "10057": {
        name: "bloodhound_hydra_black_green",
        tag: "Emerald"
    },
    "10058": {
        name: "bloodhound_hydra_green_leather_mesh_brass",
        tag: "Mangrove"
    },
    "10059": {
        name: "bloodhound_hydra_snakeskin_brass",
        tag: "Rattler"
    },
    "10060": {
        name: "bloodhound_hydra_case_hardened",
        tag: "Case Hardened"
    },
    "10061": {
        name: "specialist_webs_red",
        tag: "Crimson Web"
    },
    "10062": {
        name: "specialist_forest_brown",
        tag: "Buckshot"
    },
    "10063": {
        name: "specialist_fade",
        tag: "Fade"
    },
    "10064": {
        name: "specialist_winterhex",
        tag: "Mogul"
    },
    "10065": {
        name: "specialist_marble_fade",
        tag: "Marble Fade"
    },
    "10066": {
        name: "specialist_ricksaw_camo",
        tag: "Lt. Commander"
    },
    "10067": {
        name: "specialist_tiger_orange",
        tag: "Tiger Strike"
    },
    "10068": {
        name: "specialist_fbi",
        tag: "Field Agent"
    },
    "10069": {
        name: "slick_rezan",
        tag: "Rezan the Red"
    },
    "10070": {
        name: "slick_jaguar_white",
        tag: "Snow Leopard"
    },
    "10071": {
        name: "slick_jaguar_yellow",
        tag: "Queen Jaguar"
    },
    "10072": {
        name: "slick_stitched_black_white",
        tag: "Black Tie"
    },
    "10073": {
        name: "sporty_slingshot",
        tag: "Slingshot"
    },
    "10074": {
        name: "sporty_hunter",
        tag: "Big Game"
    },
    "10075": {
        name: "sporty_houndstooth_red",
        tag: "Scarlet Shamagh"
    },
    "10076": {
        name: "sporty_jaguar",
        tag: "Nocts"
    },
    "10077": {
        name: "motorcycle_checker_flag_blue_green",
        tag: "Finish Line"
    },
    "10078": {
        name: "motorcycle_smoke",
        tag: "Smoke Out"
    },
    "10079": {
        name: "motorcycle_carbonfiber_red",
        tag: "Blood Pressure"
    },
    "10080": {
        name: "motorcycle_commando_ksk",
        tag: "3rd Commando Company"
    },
    "10081": {
        name: "handwrap_fabric_houndstooth_orange",
        tag: "Desert Shamagh"
    },
    "10082": {
        name: "handwrap_leathery_fabric_giraffe",
        tag: "Giraffe"
    },
    "10083": {
        name: "handwrap_leathery_snakeskin_orange",
        tag: "Constrictor"
    },
    "10084": {
        name: "handwrap_leathery_caution",
        tag: "CAUTION!"
    },
    "10085": {
        name: "operation10_metalic_green",
        tag: "Jade"
    },
    "10086": {
        name: "operation10_poison_frog_black_yellow",
        tag: "Yellow-banded"
    },
    "10087": {
        name: "operation10_floral",
        tag: "Needle Point"
    },
    "10088": {
        name: "operation10_snakeskin_black",
        tag: "Unhinged"
    }
};

},{}],11:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Networkable = void 0;
const consts_1 = require("../consts");
/**
 * Represents an in-game entity.
 */
class Networkable {
    constructor(demo, index, classId, serialNum, props) {
        /**
         * Entity is scheduled for removal this tick.
         */
        this.deleting = false;
        this._demo = demo;
        this.index = index;
        this.classId = classId;
        this.serialNum = serialNum;
        this.props = props || {};
    }
    /**
     * Get the serverclass associated with this entity.
     * @returns Object representing the entity's class
     */
    get serverClass() {
        return this._demo.entities.serverClasses[this.classId];
    }
    /**
     * @returns Number uniquely identifying this entity. Should be unique throughout the entire demo.
     */
    get handle() {
        return this.index | (this.serialNum << consts_1.MAX_EDICT_BITS);
    }
    /**
     * Retrieves the value of a networked property
     * @param {string} tableName - Table name (e.g., DT_BaseEntity)
     * @param {string} varName - Network variable name (e.g., m_vecOrigin)
     * @returns {*} Property value, `undefined` if non-existent
     * @public
     */
    getProp(tableName, varName) {
        return this.props[tableName][varName];
    }
    /**
     * Interpret an array-like data table (e.g., m_iAmmo) as an array
     * @param tableName Name of the data table
     */
    getIndexedProps(tableName) {
        if (!("000" in this.props[tableName])) {
            return undefined;
        }
        return Object.values(this.props[tableName]);
    }
    /**
     * Update the value of a prop
     * @param tableName Name of the data table
     * @param varName Name of the prop to update
     * @param newValue New prop value
     */
    updateProp(tableName, varName, newValue) {
        const table = this.props[tableName];
        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
        if (table === undefined) {
            this.props[tableName] = {
                [varName]: newValue
            };
        }
        else {
            table[varName] = newValue;
        }
    }
    /**
     * True if this entity is out of the PVS.
     * Always false on GOTV demos as all entities are always in the PVS.
     */
    get isDormant() {
        return !this._demo.entities.transmitEntities.has(this.index);
    }
    toJSON() {
        return `#${this.index}(${this.serverClass.name})`;
    }
}
exports.Networkable = Networkable;

},{"../consts":3}],12:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Player = void 0;
const crosshair_1 = require("../crosshair");
const baseentity_1 = require("./baseentity");
const weapon_1 = require("./weapon");
/**
 * Represents an in-game player.
 */
class Player extends baseentity_1.BaseEntity {
    constructor(demo, index, classId, serialNum, baseline) {
        super(demo, index, classId, serialNum, baseline);
        /**
         * The 'client slot' is the index into various arrays such as the userinfo table.
         */
        this.clientSlot = index - 1;
    }
    /**
     * @returns {int} Current health
     */
    get health() {
        return this.getProp("DT_BasePlayer", "m_iHealth");
    }
    get eyeAngles() {
        return {
            pitch: this.getProp("DT_CSPlayer", "m_angEyeAngles[0]"),
            yaw: this.getProp("DT_CSPlayer", "m_angEyeAngles[1]")
        };
    }
    get position() {
        const table = this._demo.recordingClientSlot == null || this.isRecordingDemo
            ? "DT_CSLocalPlayerExclusive"
            : "DT_CSNonLocalPlayerExclusive";
        const xy = this.getProp(table, "m_vecOrigin");
        return {
            x: xy.x,
            y: xy.y,
            z: this.getProp(table, "m_vecOrigin[2]")
        };
    }
    get velocity() {
        return this._demo.recordingClientSlot == null || this.isRecordingDemo
            ? {
                x: this.getProp("DT_LocalPlayerExclusive", "m_vecVelocity[0]"),
                y: this.getProp("DT_LocalPlayerExclusive", "m_vecVelocity[1]"),
                z: this.getProp("DT_LocalPlayerExclusive", "m_vecVelocity[2]")
            }
            : { x: 0, y: 0, z: 0 };
    }
    /**
     * Speed of the entity.
     * @returns Speed in game units.
     */
    get speed() {
        const vel = this.velocity;
        return Math.sqrt(vel.x * vel.x + vel.y * vel.y + vel.z * vel.z);
    }
    /**
     * @returns Current cash
     */
    get account() {
        return this.getProp("DT_CSPlayer", "m_iAccount");
    }
    get lifeState() {
        return this.getProp("DT_BasePlayer", "m_lifeState");
    }
    /**
     * @returns lifeState == 0
     */
    get isAlive() {
        return this.lifeState === 0 /* LifeState.Alive */;
    }
    /**
     * @returns User info associated with this player
     */
    get userInfo() {
        return this._demo.entities._userInfoTable.entries[this.clientSlot]
            .userData;
    }
    /**
     * @returns User ID
     */
    get userId() {
        return this.userInfo.userId;
    }
    /**
     * @returns Steam ID
     */
    get steamId() {
        return this.userInfo.guid;
    }
    /**
     * @returns Steam 64 ID
     */
    get steam64Id() {
        if (this._steam64IdCache === undefined)
            this._steam64IdCache = this.userInfo.xuid.toString();
        return this._steam64IdCache;
    }
    /**
     * @returns Player name
     */
    get name() {
        return this.userInfo.name;
    }
    /**
     * @returns Is this player fake (i.e. a bot)
     */
    get isFakePlayer() {
        return this.userInfo.fakePlayer;
    }
    /**
     * @returns Is this player a HLTV relay
     */
    get isHltv() {
        return this.userInfo.isHltv;
    }
    /**
     * @returns Player armor (0-100)
     */
    get armor() {
        return this.getProp("DT_CSPlayer", "m_ArmorValue");
    }
    /**
     * @returns Current navmesh place name
     */
    get placeName() {
        return this.getProp("DT_BasePlayer", "m_szLastPlaceName");
    }
    /**
     * @returns Currently held weapon
     */
    get weapon() {
        return this._demo.entities.getByHandle(this.getProp("DT_BaseCombatCharacter", "m_hActiveWeapon"));
    }
    /**
     * @returns All weapons helds by this player
     */
    get weapons() {
        return this.getIndexedProps("m_hMyWeapons")
            .map(handle => this._demo.entities.getByHandle(handle))
            .filter(ent => ent ? ent instanceof weapon_1.Weapon : false);
    }
    /**
     * @returns Is the player is the bomb zone?
     */
    get isInBombZone() {
        return this.getProp("DT_CSPlayer", "m_bInBombZone");
    }
    /**
     * @returns Is the player in the buy zone?
     */
    get isInBuyZone() {
        return this.getProp("DT_CSPlayer", "m_bInBuyZone");
    }
    /**
     * @returns Is the player defusing?
     */
    get isDefusing() {
        return this.getProp("DT_CSPlayer", "m_bIsDefusing");
    }
    /**
     * @returns Does the player have a defuser?
     */
    get hasDefuser() {
        return this.getProp("DT_CSPlayer", "m_bHasDefuser");
    }
    /**
     * @returns Does the player have a helmet?
     */
    get hasHelmet() {
        return this.getProp("DT_CSPlayer", "m_bHasHelmet");
    }
    /**
     * @returns Does the player is controlling a BOT?
     */
    get isControllingBot() {
        return this.getProp("DT_CSPlayer", "m_bIsControllingBot");
    }
    /**
     * Retrieves the value of an array property on the singleton entity DT_CSPlayerResource.
     * @param {string} propName - Name of the property on DT_CSPlayerResource to retrieve
     * @returns {*} Property value
     */
    resourceProp(tableName) {
        const array = this._demo.entities.playerResource.getIndexedProps(tableName);
        return array[this.index];
    }
    /**
     * @returns How many kills the player has made
     */
    get kills() {
        return this.resourceProp("m_iKills");
    }
    /**
     * @returns How many assists the player has made
     */
    get assists() {
        return this.resourceProp("m_iAssists");
    }
    /**
     * @returns How many times the player has died
     */
    get deaths() {
        return this.resourceProp("m_iDeaths");
    }
    /**
     * @returns Cash that this player has spent this round
     */
    get cashSpendThisRound() {
        return this.resourceProp("m_iCashSpentThisRound");
    }
    /**
     * @returns Cash that the player has spent all game
     */
    get cashSpendTotal() {
        return this.resourceProp("m_iTotalCashSpent");
    }
    /**
     * @returns Whether the player holds the C4
     */
    get hasC4() {
        const pr = this._demo.entities.playerResource;
        return pr.getProp("DT_CSPlayerResource", "m_iPlayerC4") === this.index;
    }
    /**
     * @returns Score of the player
     */
    get score() {
        const pr = this._demo.entities.playerResource;
        return pr.getIndexedProps("m_iScore")[this.index];
    }
    /**
     * @returns MVPs of the player
     */
    get mvps() {
        const pr = this._demo.entities.playerResource;
        return pr.getIndexedProps("m_iMVPs")[this.index];
    }
    /**
     * @returns Clantag of the player
     */
    get clanTag() {
        const pr = this._demo.entities.playerResource;
        return pr.getIndexedProps("m_szClan")[this.index];
    }
    /**
     * @returns Has this player been spotted by any others?
     */
    get isSpotted() {
        return this.getProp("DT_BaseEntity", "m_bSpotted");
    }
    /**
     * Checks if this player has been spotted by the other.
     * Note that this still returns true if spotted by the other player even if
     * the other player is dead.
     * @param other - Other player entity
     * @returns Is this player spotted by the other?
     */
    isSpottedBy(other) {
        let bit = other.clientSlot;
        let mask = null;
        if (other.clientSlot < 32) {
            mask = this.getProp("m_bSpottedByMask", "000");
        }
        else {
            bit = other.clientSlot - 32;
            mask = this.getProp("m_bSpottedByMask", "001");
        }
        return (mask & (1 << bit)) !== 0;
    }
    /**
     * @returns Alive players that have spotted this player
     */
    get allSpotters() {
        return this._demo.players.filter(p => p.clientSlot !== this.clientSlot && p.isAlive && this.isSpottedBy(p));
    }
    /**
     * Checks if this player has spotted another.
     * Can still return true even if this player is dead.
     * @param other - Other player entity
     * @returns Has this player spotted the other?
     */
    hasSpotted(other) {
        return other.isSpottedBy(this);
    }
    /**
     * @returns Alive players that this player has spotted
     */
    get allSpotted() {
        return this._demo.players.filter(p => p.clientSlot !== this.clientSlot && p.isAlive && this.hasSpotted(p));
    }
    /**
     * @param other - Other player entity
     * @returns Whether the two players are on the same team
     */
    isFriendly(other) {
        const sameTeam = this.teamNumber === other.teamNumber;
        const teammatesAreEnemies = this._demo.conVars.vars.get("mp_teammates_are_enemies") || 0;
        return sameTeam && !teammatesAreEnemies;
    }
    /**
     * @returns Is scoped
     */
    get isScoped() {
        return this.getProp("DT_CSPlayer", "m_bIsScoped");
    }
    /**
     * @returns Is walking
     */
    get isWalking() {
        return this.getProp("DT_CSPlayer", "m_bIsWalking");
    }
    /**
     * @returns Player is transitioning from ducked -> standing or standing -> ducked
     */
    get isDucking() {
        return this.getProp("DT_Local", "m_bDucking");
    }
    /**
     * @returns Is ducked
     */
    get isDucked() {
        return this.getProp("DT_Local", "m_bDucked");
    }
    /**
     * @returns Duration of a flash that hit the player
     */
    get flashDuration() {
        return this.getProp("DT_CSPlayer", "m_flFlashDuration");
    }
    /**
     * @returns Current equipment value
     */
    get currentEquipmentValue() {
        return this.getProp("DT_CSPlayer", "m_unCurrentEquipmentValue");
    }
    /**
     * @returns Round start equipment value
     */
    get roundStartEquipmentValue() {
        return this.getProp("DT_CSPlayer", "m_unRoundStartEquipmentValue");
    }
    /**
     * @returns Freeze time end equipment value
     */
    get freezeTimeEndEquipmentValue() {
        return this.getProp("DT_CSPlayer", "m_unFreezetimeEndEquipmentValue");
    }
    /**
     * @returns Object representing the player's performance per round
     */
    get matchStats() {
        const kills = this.getIndexedProps("m_iMatchStats_Kills");
        const damage = this.getIndexedProps("m_iMatchStats_Damage");
        const equipmentValue = this.getIndexedProps("m_iMatchStats_EquipmentValue");
        const moneySaved = this.getIndexedProps("m_iMatchStats_MoneySaved");
        const killReward = this.getIndexedProps("m_iMatchStats_KillReward");
        const liveTime = this.getIndexedProps("m_iMatchStats_LiveTime");
        const deaths = this.getIndexedProps("m_iMatchStats_Deaths");
        const assists = this.getIndexedProps("m_iMatchStats_Assists");
        const headShotKills = this.getIndexedProps("m_iMatchStats_HeadShotKills");
        const objective = this.getIndexedProps("m_iMatchStats_Objective");
        const rounds = new Array();
        for (let roundIdx = 0; roundIdx < kills.length; ++roundIdx) {
            rounds.push({
                kills: kills[roundIdx],
                damage: damage[roundIdx],
                equipmentValue: equipmentValue[roundIdx],
                moneySaved: moneySaved[roundIdx],
                killReward: killReward[roundIdx],
                liveTime: liveTime[roundIdx],
                deaths: deaths[roundIdx],
                assists: assists[roundIdx],
                headShotKills: headShotKills[roundIdx],
                objective: objective[roundIdx]
            });
        }
        return rounds;
    }
    /**
     * @returns Object representing user-customisable crosshair settings.
     */
    get crosshairInfo() {
        return (0, crosshair_1.decodeCrosshairCode)(this.resourceProp("m_szCrosshairCodes"));
    }
    /**
     * @returns true if this player is recording the demo from their POV.
     */
    get isRecordingDemo() {
        return this._demo.recordingClientSlot === this.clientSlot;
    }
}
exports.Player = Player;

},{"../crosshair":5,"./baseentity":8,"./weapon":15}],13:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Projectile = void 0;
const baseentity_1 = require("./baseentity");
/**
 * Represents a grenade projectile.
 */
class Projectile extends baseentity_1.BaseEntity {
    /**
     * @returns {GrenadeType} Type of grenade that this projectile is.
     */
    get grenadeType() {
        switch (this.modelName) {
            case "models/Weapons/w_eq_fraggrenade_dropped.mdl":
                return "explosive";
            case "models/Weapons/w_eq_flashbang_dropped.mdl":
                return "flashbang";
            case "models/Weapons/w_eq_molotov_dropped.mdl":
                return "molotov";
            case "models/Weapons/w_eq_incendiarygrenade_dropped.mdl":
                return "incendiary";
            case "models/Weapons/w_eq_decoy_dropped.mdl":
                return "decoy";
            case "models/Weapons/w_eq_smokegrenade_thrown.mdl":
                return "smoke";
            default:
                throw new Error(`Unknown projectile with model: ${this.modelName}`);
        }
    }
}
exports.Projectile = Projectile;

},{"./baseentity":8}],14:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Team = void 0;
const networkable_1 = require("./networkable");
const player_1 = require("./player");
/**
 * Represents an in-game team.
 */
class Team extends networkable_1.Networkable {
    /**
     * @returns {Player[]} All players in this team
     */
    get members() {
        // UNSAFE: cast here as members will always be players
        return this.getProp("DT_Team", '"player_array"')
            .map(index => this._demo.entities.entities.get(index))
            .filter(player => player instanceof player_1.Player);
    }
    /**
     * @returns {int} 0: Unassigned, 1: Spectator, 2: Terrorist, 3: Counter-Terrorist
     */
    get teamNumber() {
        return this.getProp("DT_Team", "m_iTeamNum");
    }
    /**
     * @returns Clan name
     */
    get clanName() {
        return this.getProp("DT_Team", "m_szClanTeamname");
    }
    /**
     * @returns 'SPECTATOR', 'TERRORIST' or 'COUNTERTERRORIST'
     */
    get teamName() {
        return this.getProp("DT_Team", "m_szTeamname");
    }
    /**
     * @returns Total score
     */
    get score() {
        return this.getProp("DT_Team", "m_scoreTotal");
    }
    /**
     * @returns First half score
     */
    get scoreFirstHalf() {
        return this.getProp("DT_Team", "m_scoreFirstHalf");
    }
    /**
     * @returns Second half score
     */
    get scoreSecondHalf() {
        return this.getProp("DT_Team", "m_scoreSecondHalf");
    }
    /**
     * @returns Team flag image
     */
    get flagImage() {
        return this.getProp("DT_Team", "m_szTeamFlagImage");
    }
    /**
     * @returns Team logo image
     */
    get logoImage() {
        return this.getProp("DT_Team", "m_szTeamLogoImage");
    }
}
exports.Team = Team;

},{"./networkable":11,"./player":12}],15:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Weapon = void 0;
const baseentity_1 = require("./baseentity");
const itemdefs_1 = require("./itemdefs");
const qualities = [
    "normal",
    "genuine",
    "vintage",
    "unusual",
    "unique",
    "community",
    "developer",
    "selfmade",
    "customized",
    "strange",
    "completed",
    "haunted",
    "tournament",
    "favored"
];
/**
 * Represents an in-game weapon (guns, grenades, knifes).
 */
class Weapon extends baseentity_1.BaseEntity {
    /**
     * @returns Owning player, if any
     */
    get owner() {
        return super.owner;
    }
    /**
     * @returns Item definition index
     */
    get itemIndex() {
        return this.getProp("DT_ScriptCreatedItem", "m_iItemDefinitionIndex");
    }
    /**
     * @returns Name of the weapon (e.g. "Five-SeveN")
     */
    get itemName() {
        const weaponId = this.itemIndex;
        const itemDefinition = itemdefs_1.itemDefinitionIndexMap[weaponId];
        return itemDefinition !== undefined ? itemDefinition.itemName : null;
    }
    /**
     * @returns Entity class name of the weapon (e.g. "weapon_ak47")
     */
    get className() {
        const weaponId = this.itemIndex;
        const itemDefinition = itemdefs_1.itemDefinitionIndexMap[weaponId];
        return itemDefinition !== undefined ? itemDefinition.className : null;
    }
    /**
     * @returns Previous owner
     */
    get prevOwner() {
        const handle = this.getProp("DT_WeaponCSBase", "m_hPrevOwner");
        return this._demo.entities.getByHandle(handle);
    }
    /**
     * @returns Amount of ammo in the clip of the weapon
     */
    get clipAmmo() {
        return this.getProp("DT_BaseCombatWeapon", "m_iClip1");
    }
    /**
     * @returns The amount ammo this weapon has in reserve
     */
    get reserveAmmo() {
        return this.getProp("DT_BaseCombatWeapon", "m_iPrimaryReserveAmmoCount");
    }
    /**
     * @returns The amount of ammo the owner holds for this weapon. Null if no owner.
     */
    get ownerAmmo() {
        if (!this.owner)
            return null;
        const ammoType = this.getProp("DT_LocalWeaponData", "m_iPrimaryAmmoType");
        if (ammoType === -1)
            return null;
        return this.owner.getIndexedProps("m_iAmmo")[ammoType];
    }
    /**
     * @returns Quality of the item.
     */
    get quality() {
        const quality = this.getProp("DT_ScriptCreatedItem", "m_iEntityQuality");
        return qualities[quality];
    }
}
exports.Weapon = Weapon;

},{"./baseentity":8,"./itemdefs":10}],16:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.EntityHandle = void 0;
const consts_1 = require("./consts");
class EntityHandle {
    constructor(value) {
        this.value = value;
    }
    get isValid() {
        return this.value !== consts_1.INVALID_NETWORKED_EHANDLE_VALUE;
    }
    get index() {
        return this.value & consts_1.NETWORKED_EHANDLE_ENT_ENTRY_MASK;
    }
    get serialNum() {
        return this.value >> consts_1.MAX_EDICT_BITS;
    }
}
exports.EntityHandle = EntityHandle;

},{"./consts":3}],17:[function(require,module,exports){
"use strict";
/* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument, sonarjs/no-duplicated-branches */
// DO NOT MODIFY!
// Auto-generated by ./generators/eventtypes.ts
Object.defineProperty(exports, "__esModule", { value: true });
exports.annotateEvent = void 0;
const itemdefs_1 = require("./entities/itemdefs");
const Long = require("long");
function annotateEvent(entities, eventName, event) {
    if (eventName === "bomb_begindefuse") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "bomb_beginplant") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "bomb_defused") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "bomb_dropped") {
        event.player = entities.getByUserId(event.userid);
        event.entity = entities.entities.get(event.entindex);
    }
    else if (eventName === "bomb_exploded") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "bomb_pickup") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "bomb_planted") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "bot_takeover") {
        event.player = entities.getByUserId(event.userid);
        event.bot = entities.getByUserId(event.botid);
    }
    else if (eventName === "cs_win_panel_round") {
        event.player = entities.entities.get(event.funfact_player);
    }
    else if (eventName === "decoy_detonate") {
        event.player = entities.getByUserId(event.userid);
        event.entity = entities.entities.get(event.entityid);
    }
    else if (eventName === "decoy_started") {
        event.player = entities.getByUserId(event.userid);
        event.entity = entities.entities.get(event.entityid);
    }
    else if (eventName === "defuser_dropped") {
        event.entity = entities.entities.get(event.entityid);
    }
    else if (eventName === "defuser_pickup") {
        event.entity = entities.entities.get(event.entityid);
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "flashbang_detonate") {
        event.player = entities.getByUserId(event.userid);
        event.entity = entities.entities.get(event.entityid);
    }
    else if (eventName === "hegrenade_detonate") {
        event.player = entities.getByUserId(event.userid);
        event.entity = entities.entities.get(event.entityid);
    }
    else if (eventName === "hostage_hurt") {
        event.player = entities.getByUserId(event.userid);
        event.entity = entities.entities.get(event.hostage);
    }
    else if (eventName === "hostage_killed") {
        event.player = entities.getByUserId(event.userid);
        event.entity = entities.entities.get(event.hostage);
    }
    else if (eventName === "hostage_rescued") {
        event.player = entities.getByUserId(event.userid);
        event.entity = entities.entities.get(event.hostage);
    }
    else if (eventName === "inferno_expire") {
        event.entity = entities.entities.get(event.entityid);
    }
    else if (eventName === "inferno_startburn") {
        event.entity = entities.entities.get(event.entityid);
    }
    else if (eventName === "item_equip") {
        event.player = entities.getByUserId(event.userid);
        event.itemDefinition = itemdefs_1.itemDefinitionIndexMap[event.defindex] || null;
    }
    else if (eventName === "item_pickup") {
        event.player = entities.getByUserId(event.userid);
        event.itemDefinition = itemdefs_1.itemDefinitionIndexMap[event.defindex] || null;
    }
    else if (eventName === "item_remove") {
        event.player = entities.getByUserId(event.userid);
        event.itemDefinition = itemdefs_1.itemDefinitionIndexMap[event.defindex] || null;
    }
    else if (eventName === "items_gifted") {
        event.entity = entities.getByAccountId(event.accountid);
    }
    else if (eventName === "other_death") {
        event.victim = entities.entities.get(event.otherid);
        event.attackerEntity = entities.getByUserId(event.attacker);
        event.itemDefinition =
            event.weapon_fauxitemid != ""
                ? itemdefs_1.itemDefinitionIndexMap[Long.fromString(event.weapon_fauxitemid, true)
                    .and(0xffff)
                    .toString()]
                : null;
        event.paintKit =
            event.weapon_fauxitemid != ""
                ? itemdefs_1.paintKitIndexMap[Long.fromString(event.weapon_fauxitemid, true)
                    .shiftRightUnsigned(16)
                    .and(0xffff)
                    .toString()]
                : null;
        event.originalOwner = entities.getBySteam64Id(event.weapon_originalowner_xuid);
    }
    else if (eventName === "player_blind") {
        event.player = entities.getByUserId(event.userid);
        event.attackerEntity = entities.getByUserId(event.attacker);
        event.entity = entities.entities.get(event.entityid);
    }
    else if (eventName === "player_changename") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "player_chat") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "player_connect_full") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "player_death") {
        event.player = entities.getByUserId(event.userid);
        event.attackerEntity = entities.getByUserId(event.attacker);
        event.assisterEntity = entities.getByUserId(event.assister);
        event.itemDefinition =
            event.weapon_fauxitemid != ""
                ? itemdefs_1.itemDefinitionIndexMap[Long.fromString(event.weapon_fauxitemid, true)
                    .and(0xffff)
                    .toString()]
                : null;
        event.paintKit =
            event.weapon_fauxitemid != ""
                ? itemdefs_1.paintKitIndexMap[Long.fromString(event.weapon_fauxitemid, true)
                    .shiftRightUnsigned(16)
                    .and(0xffff)
                    .toString()]
                : null;
        event.originalOwner = entities.getBySteam64Id(event.weapon_originalowner_xuid);
    }
    else if (eventName === "player_disconnect") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "player_falldamage") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "player_footstep") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "player_hurt") {
        event.player = entities.getByUserId(event.userid);
        event.attackerEntity = entities.getByUserId(event.attacker);
    }
    else if (eventName === "player_info") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "player_jump") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "player_spawn") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "player_team") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "round_mvp") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "smokegrenade_detonate") {
        event.player = entities.getByUserId(event.userid);
        event.entity = entities.entities.get(event.entityid);
    }
    else if (eventName === "smokegrenade_expired") {
        event.player = entities.getByUserId(event.userid);
        event.entity = entities.entities.get(event.entityid);
    }
    else if (eventName === "survival_paradrop_break") {
        event.entity = entities.entities.get(event.entityid);
    }
    else if (eventName === "survival_paradrop_spawn") {
        event.entity = entities.entities.get(event.entityid);
    }
    else if (eventName === "tournament_reward") {
        event.itemDefinition = itemdefs_1.itemDefinitionIndexMap[event.defindex] || null;
        event.entity = entities.getByAccountId(event.accountid);
    }
    else if (eventName === "weapon_fire") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "weapon_fire_on_empty") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "weapon_outofammo") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "weapon_reload") {
        event.player = entities.getByUserId(event.userid);
    }
    else if (eventName === "weapon_zoom") {
        event.player = entities.getByUserId(event.userid);
    }
    return event;
}
exports.annotateEvent = annotateEvent;

},{"./entities/itemdefs":10,"long":712}],18:[function(require,module,exports){
(function (Buffer){(function (){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BitView = exports.BitStream = void 0;
/* eslint-disable @typescript-eslint/unbound-method */
const bit_buffer_1 = require("bit-buffer");
Object.defineProperty(exports, "BitStream", { enumerable: true, get: function () { return bit_buffer_1.BitStream; } });
Object.defineProperty(exports, "BitView", { enumerable: true, get: function () { return bit_buffer_1.BitView; } });
const COORD_INTEGER_BITS = 14;
const COORD_FRACTIONAL_BITS = 5;
const COORD_DENOMINATOR = 1 << COORD_FRACTIONAL_BITS;
const COORD_RESOLUTION = 1.0 / COORD_DENOMINATOR;
// Special threshold for networking multiplayer origins
const COORD_INTEGER_BITS_MP = 11;
const COORD_FRACTIONAL_BITS_MP_LOWPRECISION = 3;
const COORD_DENOMINATOR_LOWPRECISION = 1 << COORD_FRACTIONAL_BITS_MP_LOWPRECISION;
const COORD_RESOLUTION_LOWPRECISION = 1.0 / COORD_DENOMINATOR_LOWPRECISION;
const NORMAL_FRACTIONAL_BITS = 11;
const NORMAL_DENOMINATOR = (1 << NORMAL_FRACTIONAL_BITS) - 1;
const NORMAL_RESOLUTION = 1.0 / NORMAL_DENOMINATOR;
const MAX_VAR_INT32_BYTES = 5;
bit_buffer_1.BitStream.from = function from(array) {
    return new bit_buffer_1.BitStream(array.buffer, array.byteOffset, array.byteLength);
};
bit_buffer_1.BitStream.prototype.readString = function (bytes) {
    let s = "";
    let record = true;
    for (let i = 0; i < bytes; ++i) {
        const c = this.readUint8();
        // Stop appending chars once we hit 0x00
        if (c === 0x00) {
            record = false;
        }
        else if (record) {
            s += String.fromCharCode(c);
        }
    }
    return s;
};
bit_buffer_1.BitStream.prototype.readBytes = function (bytes) {
    const arr = new Array(bytes);
    for (let i = 0; i < bytes; ++i) {
        arr[i] = this.readUInt8();
    }
    return Buffer.from(arr);
};
bit_buffer_1.BitStream.prototype.readOneBit = function () {
    return this.readBits(1, false) === 1;
};
bit_buffer_1.BitStream.prototype.readUBits = bit_buffer_1.BitStream.prototype.readBits;
bit_buffer_1.BitStream.prototype.readSBits = function (bits) {
    return this.readBits(bits, true);
};
bit_buffer_1.BitStream.prototype.readUBitVar = function () {
    let ret = this.readUBits(6);
    switch (ret & (16 | 32)) {
        case 16:
            ret = (ret & 15) | (this.readUBits(4) << 4);
            break;
        case 32:
            ret = (ret & 15) | (this.readUBits(8) << 4);
            break;
        case 48:
            ret = (ret & 15) | (this.readUBits(32 - 4) << 4);
            break;
    }
    return ret;
};
bit_buffer_1.BitStream.prototype.readBitCoord = function () {
    let intval = this.readOneBit() ? 1 : 0;
    let fractval = this.readOneBit() ? 1 : 0;
    if (!intval && !fractval) {
        return 0.0;
    }
    const signbit = this.readOneBit();
    if (intval) {
        intval = this.readUBits(COORD_INTEGER_BITS) + 1;
    }
    if (fractval) {
        fractval = this.readUBits(COORD_FRACTIONAL_BITS);
    }
    let value = intval + fractval * COORD_RESOLUTION;
    if (signbit) {
        value = -value;
    }
    return value;
};
bit_buffer_1.BitStream.prototype.readUVarInt32 = function () {
    let result = 0;
    let count = 0;
    let bytes;
    do {
        if (count === MAX_VAR_INT32_BYTES) {
            return result;
        }
        bytes = this.readUInt8();
        result |= (bytes & 0x7f) << (7 * count);
        ++count;
    } while (bytes & 0x80);
    return result;
};
bit_buffer_1.BitStream.prototype.readVarInt32 = function () {
    const result = this.readUVarInt32();
    return (result >> 1) ^ -(result & 1);
};
bit_buffer_1.BitStream.prototype.readBitCoordMPNone = function () {
    const inBounds = this.readOneBit();
    let intval = this.readOneBit() ? 1 : 0;
    const signbit = this.readOneBit();
    if (intval) {
        if (inBounds) {
            intval = this.readUBits(COORD_INTEGER_BITS_MP) + 1;
        }
        else {
            intval = this.readUBits(COORD_INTEGER_BITS) + 1;
        }
    }
    const fractval = this.readUBits(COORD_FRACTIONAL_BITS);
    let value = intval + fractval * COORD_RESOLUTION;
    if (signbit) {
        value = -value;
    }
    return value;
};
bit_buffer_1.BitStream.prototype.readBitCoordMPLowPrecision = function () {
    const inBounds = this.readOneBit();
    let intval = this.readOneBit() ? 1 : 0;
    const signbit = this.readOneBit();
    if (intval) {
        if (inBounds) {
            intval = this.readUBits(COORD_INTEGER_BITS_MP) + 1;
        }
        else {
            intval = this.readUBits(COORD_INTEGER_BITS) + 1;
        }
    }
    const fractval = this.readUBits(COORD_FRACTIONAL_BITS_MP_LOWPRECISION);
    let value = intval + fractval * COORD_RESOLUTION_LOWPRECISION;
    if (signbit) {
        value = -value;
    }
    return value;
};
bit_buffer_1.BitStream.prototype.readBitCoordMPIntegral = function () {
    const inBounds = this.readOneBit();
    if (!this.readOneBit()) {
        return 0.0;
    }
    const signbit = this.readOneBit();
    let value;
    if (inBounds) {
        value = this.readUBits(COORD_INTEGER_BITS_MP) + 1;
    }
    else {
        value = this.readUBits(COORD_INTEGER_BITS) + 1;
    }
    if (signbit) {
        value = -value;
    }
    return value;
};
bit_buffer_1.BitStream.prototype.readBitNormal = function () {
    const signbit = this.readOneBit();
    const fractval = this.readUBits(NORMAL_FRACTIONAL_BITS);
    let value = fractval * NORMAL_RESOLUTION;
    if (signbit) {
        value = -value;
    }
    return value;
};
bit_buffer_1.BitStream.prototype.readBitCellCoordNone = function (bits) {
    const intval = this.readUBits(bits);
    const fractval = this.readUBits(COORD_FRACTIONAL_BITS);
    return intval + fractval * COORD_RESOLUTION;
};
bit_buffer_1.BitStream.prototype.readBitCellCoordLowPrecision = function (bits) {
    const intval = this.readUBits(bits);
    const fractval = this.readUBits(COORD_FRACTIONAL_BITS_MP_LOWPRECISION);
    return intval + fractval * COORD_RESOLUTION_LOWPRECISION;
};
bit_buffer_1.BitStream.prototype.readBitCellCoordIntegral = function (bits) {
    return this.readUBits(bits);
};
bit_buffer_1.BitStream.prototype.readCString = function () {
    let s = "";
    // eslint-disable-next-line no-constant-condition
    while (true) {
        const c = this.readUint8();
        // Stop appending chars once we hit 0x00
        if (c === 0x00) {
            break;
        }
        s += String.fromCharCode(c);
    }
    return s;
};
bit_buffer_1.BitStream.prototype.readUInt8 = bit_buffer_1.BitStream.prototype.readUint8;
bit_buffer_1.BitStream.prototype.readUInt16 = bit_buffer_1.BitStream.prototype.readUint16;
bit_buffer_1.BitStream.prototype.readUInt32 = bit_buffer_1.BitStream.prototype.readUint32;
bit_buffer_1.BitStream.prototype.writeUInt8 = bit_buffer_1.BitStream.prototype.writeUint8;
bit_buffer_1.BitStream.prototype.writeUInt16 = bit_buffer_1.BitStream.prototype.writeUint16;
bit_buffer_1.BitStream.prototype.writeUInt32 = bit_buffer_1.BitStream.prototype.writeUint32;

}).call(this)}).call(this,require("buffer").Buffer)

},{"bit-buffer":79,"buffer":81}],19:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.GameEvent = void 0;
const assert = require("assert");
var EventKeyType;
(function (EventKeyType) {
    EventKeyType[EventKeyType["TYPE_STRING"] = 1] = "TYPE_STRING";
    EventKeyType[EventKeyType["TYPE_FLOAT"] = 2] = "TYPE_FLOAT";
    EventKeyType[EventKeyType["TYPE_LONG"] = 3] = "TYPE_LONG";
    EventKeyType[EventKeyType["TYPE_SHORT"] = 4] = "TYPE_SHORT";
    EventKeyType[EventKeyType["TYPE_BYTE"] = 5] = "TYPE_BYTE";
    EventKeyType[EventKeyType["TYPE_BOOL"] = 6] = "TYPE_BOOL";
    EventKeyType[EventKeyType["TYPE_UINT64"] = 7] = "TYPE_UINT64";
    EventKeyType[EventKeyType["TYPE_WSTRING"] = 8] = "TYPE_WSTRING";
})(EventKeyType || (EventKeyType = {}));
class GameEvent {
    constructor(descriptor) {
        this.name = descriptor.name;
        this.id = descriptor.eventid;
        this.keyNames = descriptor.keys.map(key => key.name);
    }
    messageToObject(eventMsg) {
        assert(eventMsg.eventid === this.id);
        const event = {};
        for (let i = 0; i < this.keyNames.length; ++i) {
            const keyName = this.keyNames[i];
            const value = eventMsg.keys[i];
            switch (value.type) {
                case EventKeyType.TYPE_STRING:
                    event[keyName] = value.valString;
                    break;
                case EventKeyType.TYPE_FLOAT:
                    event[keyName] = value.valFloat;
                    break;
                case EventKeyType.TYPE_LONG:
                    event[keyName] = value.valLong;
                    break;
                case EventKeyType.TYPE_SHORT:
                    event[keyName] = value.valShort;
                    break;
                case EventKeyType.TYPE_BYTE:
                    event[keyName] = value.valByte;
                    break;
                case EventKeyType.TYPE_BOOL:
                    event[keyName] = value.valBool;
                    break;
                case EventKeyType.TYPE_UINT64:
                    event[keyName] = value.valUint64;
                    break;
                case EventKeyType.TYPE_WSTRING:
                    event[keyName] = value.valWstring;
                    break;
            }
        }
        return event;
    }
}
exports.GameEvent = GameEvent;

},{"assert":73}],20:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.GameEvents = void 0;
const events_1 = require("events");
const gameevent_1 = require("./gameevent");
const eventtypes_1 = require("./eventtypes");
/**
 * Manages game events for a demo file.
 */
class GameEvents extends events_1.EventEmitter {
    constructor() {
        super(...arguments);
        this.gameEventList = [];
        this._tickEvents = [];
    }
    listen(demo) {
        const entities = demo.entities;
        demo.on("svc_GameEventList", this._handleGameEventList.bind(this));
        demo.on("svc_GameEvent", msg => {
            const event = this.gameEventList[msg.eventid];
            if (!event) {
                return;
            }
            const eventVars = event.messageToObject(msg);
            // buffer game events until the end of the tick
            this._tickEvents.push({
                name: event.name,
                event: (0, eventtypes_1.annotateEvent)(entities, event.name, eventVars)
            });
        });
        demo.on("tickend", () => {
            this._tickEvents.forEach(event => {
                this.emit(event.name, event.event);
                this.emit("event", {
                    name: event.name,
                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                    event: event.event
                });
            });
            this._tickEvents = [];
        });
    }
    _handleGameEventList(msg) {
        for (const descriptor of msg.descriptors) {
            this.gameEventList[descriptor.eventid] = new gameevent_1.GameEvent(descriptor);
        }
    }
}
exports.GameEvents = GameEvents;

},{"./eventtypes":17,"./gameevent":19,"events":84}],21:[function(require,module,exports){
"use strict";
// Copied from https://github.com/DSergiu/node-ice
// ---
// The MIT License
//
// Copyright (c) 2010-2017 Google, Inc. http://angularjs.org
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
Object.defineProperty(exports, "__esModule", { value: true });
exports.IceKey = void 0;
class IceKey {
    // Create a new ICE key with the specified level.
    constructor(level) {
        this.cipherHolder = new Uint8Array(8);
        this.plainHolder = new Uint8Array(8);
        if (!IceKey.spBoxInitialised) {
            this.spBoxInit();
            IceKey.spBoxInitialised = true;
        }
        if (level < 1) {
            this.size = 1;
            this.rounds = 8;
        }
        else {
            this.size = level;
            this.rounds = level * 16;
        }
        this.keySchedule = [];
        for (let i = 0; i < this.rounds; i++) {
            this.keySchedule[i] = [];
            for (let j = 0; j < 3; j++) {
                this.keySchedule[i][j] = 0;
            }
        }
    }
    // Return the key size, in bytes.
    keySize() {
        return this.size * 8;
    }
    // Return the block size, in bytes.
    blockSize() {
        return 8;
    }
    // Set the key schedule of an ICE key.
    set(key) {
        const kb = new Uint16Array(4);
        for (let i = 0; i < 4; i++)
            kb[i] = 0;
        if (this.rounds === 8) {
            for (let i = 0; i < 4; i++)
                kb[3 - i] = ((key[i * 2] & 0xff) << 8) | (key[i * 2 + 1] & 0xff);
            this.scheduleBuild(kb, 0, 0);
            return;
        }
        for (let i = 0; i < this.size; i++) {
            for (let j = 0; j < 4; j++)
                kb[3 - j] =
                    ((key[i * 8 + j * 2] & 0xff) << 8) |
                        (key[i * 8 + j * 2 + 1] & 0xff);
            this.scheduleBuild(kb, i * 8, 0);
            this.scheduleBuild(kb, this.rounds - 8 - i * 8, 8);
        }
    }
    // Clear the key schedule to prevent memory snooping.
    clear() {
        for (let i = 0; i < this.rounds; i++)
            for (let j = 0; j < 3; j++)
                this.keySchedule[i][j] = 0;
    }
    // Encrypt a block of 8 bytes of data.
    encrypt(plaintext, ciphertext) {
        let i;
        let l = 0;
        let r = 0;
        for (i = 0; i < 4; i++) {
            l |= (plaintext[i] & 0xff) << (24 - i * 8);
            r |= (plaintext[i + 4] & 0xff) << (24 - i * 8);
        }
        for (i = 0; i < this.rounds; i += 2) {
            l ^= this.roundFunc(r, this.keySchedule[i]);
            r ^= this.roundFunc(l, this.keySchedule[i + 1]);
        }
        for (i = 0; i < 4; i++) {
            ciphertext[3 - i] = Number(r & 0xff);
            ciphertext[7 - i] = Number(l & 0xff);
            r >>>= 8;
            l >>>= 8;
        }
    }
    // Decrypt a block of 8 bytes of data.
    decrypt(ciphertext, plaintext) {
        let i;
        let l = 0;
        let r = 0;
        for (i = 0; i < 4; i++) {
            l |= (ciphertext[i] & 0xff) << (24 - i * 8);
            r |= (ciphertext[i + 4] & 0xff) << (24 - i * 8);
        }
        for (i = this.rounds - 1; i > 0; i -= 2) {
            l ^= this.roundFunc(r, this.keySchedule[i]);
            r ^= this.roundFunc(l, this.keySchedule[i - 1]);
        }
        for (i = 0; i < 4; i++) {
            plaintext[3 - i] = Number(r & 0xff);
            plaintext[7 - i] = Number(l & 0xff);
            r >>>= 8;
            l >>>= 8;
        }
    }
    decryptUint8Array(cipherArray, plainArray, from, to) {
        if (from == null)
            from = 0;
        if (to == null)
            to = cipherArray.length;
        let k = 0;
        // decrypt full blocks
        while (from + 8 <= to) {
            for (let i = 0; i < 8; i++) {
                this.cipherHolder[i] = cipherArray[from + i];
            }
            this.decrypt(this.cipherHolder, this.plainHolder);
            for (let i = 0; i < 8; i++) {
                plainArray[k + i] = this.plainHolder[i];
            }
            k += 8;
            from += 8;
        }
        // remaining bytes do not get encryption, just copy them
        if (((to - from) & 0x7) !== 0) {
            for (let i = from; i < to; i++) {
                plainArray[k++] = cipherArray[i];
            }
        }
    }
    // 8-bit Galois Field multiplication of a by b, modulo m.
    // Just like arithmetic multiplication, except that
    // additions and subtractions are replaced by XOR.
    gf_mult(a, b, m) {
        let res = 0;
        while (b !== 0) {
            if ((b & 1) !== 0)
                res ^= a;
            a <<= 1;
            b >>>= 1;
            if (a >= 256)
                a ^= m;
        }
        return res;
    }
    // 8-bit Galois Field exponentiation.
    // Raise the base to the power of 7, modulo m.
    gf_exp7(b, m) {
        let x;
        if (b === 0)
            return 0;
        x = this.gf_mult(b, b, m);
        x = this.gf_mult(b, x, m);
        x = this.gf_mult(x, x, m);
        return this.gf_mult(b, x, m);
    }
    // Carry out the ICE 32-bit permutation.
    perm32(x) {
        let res = 0;
        let i = 0;
        while (x !== 0) {
            if ((x & 1) !== 0)
                res |= IceKey.pBox[i];
            i++;
            x >>>= 1;
        }
        return res;
    }
    // Initialise the substitution/permutation boxes.
    spBoxInit() {
        IceKey.spBox = [];
        for (let i = 0; i < 4; i++) {
            IceKey.spBox[i] = [];
            for (let j = 0; j < 1024; j++) {
                IceKey.spBox[i][j] = 0;
            }
        }
        for (let i = 0; i < 1024; i++) {
            const col = (i >>> 1) & 0xff;
            const row = (i & 0x1) | ((i & 0x200) >>> 8);
            let x;
            x =
                this.gf_exp7(col ^ IceKey.sXor[0][row], IceKey.sMod[0][row]) << 24;
            IceKey.spBox[0][i] = this.perm32(x);
            x =
                this.gf_exp7(col ^ IceKey.sXor[1][row], IceKey.sMod[1][row]) << 16;
            IceKey.spBox[1][i] = this.perm32(x);
            x = this.gf_exp7(col ^ IceKey.sXor[2][row], IceKey.sMod[2][row]) << 8;
            IceKey.spBox[2][i] = this.perm32(x);
            x = this.gf_exp7(col ^ IceKey.sXor[3][row], IceKey.sMod[3][row]);
            IceKey.spBox[3][i] = this.perm32(x);
        }
    }
    // Set 8 rounds [n, n+7] of the key schedule of an ICE key.
    scheduleBuild(kb, n, krotIdx) {
        let i;
        for (i = 0; i < 8; i++) {
            let j;
            const kr = IceKey.keyrot[krotIdx + i];
            const subkey = this.keySchedule[n + i];
            for (j = 0; j < 3; j++)
                this.keySchedule[n + i][j] = 0;
            for (j = 0; j < 15; j++) {
                let k;
                const curSk = j % 3;
                for (k = 0; k < 4; k++) {
                    const curKb = kb[(kr + k) & 3];
                    const bit = curKb & 1;
                    subkey[curSk] = (subkey[curSk] << 1) | bit;
                    kb[(kr + k) & 3] = (curKb >>> 1) | ((bit ^ 1) << 15);
                }
            }
        }
    }
    // The single round ICE f function.
    roundFunc(p, subkey) {
        const tl = ((p >>> 16) & 0x3ff) | (((p >>> 14) | (p << 18)) & 0xffc00);
        const tr = (p & 0x3ff) | ((p << 2) & 0xffc00);
        let al = subkey[2] & (tl ^ tr);
        let ar = al ^ tr;
        al ^= tl;
        al ^= subkey[0];
        ar ^= subkey[1];
        return (IceKey.spBox[0][al >>> 10] |
            IceKey.spBox[1][al & 0x3ff] |
            IceKey.spBox[2][ar >>> 10] |
            IceKey.spBox[3][ar & 0x3ff]);
    }
}
exports.IceKey = IceKey;
IceKey.spBoxInitialised = false;
IceKey.sMod = [
    [333, 313, 505, 369],
    [379, 375, 319, 391],
    [361, 445, 451, 397],
    [397, 425, 395, 505]
];
IceKey.sXor = [
    [0x83, 0x85, 0x9b, 0xcd],
    [0xcc, 0xa7, 0xad, 0x41],
    [0x4b, 0x2e, 0xd4, 0x33],
    [0xea, 0xcb, 0x2e, 0x04]
];
IceKey.pBox = [
    0x00000001, 0x00000080, 0x00000400, 0x00002000, 0x00080000, 0x00200000,
    0x01000000, 0x40000000, 0x00000008, 0x00000020, 0x00000100, 0x00004000,
    0x00010000, 0x00800000, 0x04000000, 0x20000000, 0x00000004, 0x00000010,
    0x00000200, 0x00008000, 0x00020000, 0x00400000, 0x08000000, 0x10000000,
    0x00000002, 0x00000040, 0x00000800, 0x00001000, 0x00040000, 0x00100000,
    0x02000000, 0x80000000
];
IceKey.keyrot = [0, 1, 2, 3, 2, 1, 3, 0, 1, 3, 2, 0, 3, 1, 0, 2];

},{}],22:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.findByType = exports.findByName = exports.messages = void 0;
const netmessages_1 = require("./protobufs/netmessages");
exports.messages = [];
exports.messages[netmessages_1.NETMessages.net_NOP] = { name: "net_NOP", class: netmessages_1.CNETMsgNOP };
exports.messages[netmessages_1.NETMessages.net_Disconnect] = {
    name: "net_Disconnect",
    class: netmessages_1.CNETMsgDisconnect
};
exports.messages[netmessages_1.NETMessages.net_File] = { name: "net_File", class: netmessages_1.CNETMsgFile };
exports.messages[netmessages_1.NETMessages.net_SplitScreenUser] = {
    name: "net_SplitScreenUser",
    class: netmessages_1.CNETMsgSplitScreenUser
};
exports.messages[netmessages_1.NETMessages.net_Tick] = { name: "net_Tick", class: netmessages_1.CNETMsgTick };
exports.messages[netmessages_1.NETMessages.net_StringCmd] = {
    name: "net_StringCmd",
    class: netmessages_1.CNETMsgStringCmd
};
exports.messages[netmessages_1.NETMessages.net_SetConVar] = {
    name: "net_SetConVar",
    class: netmessages_1.CNETMsgSetConVar
};
exports.messages[netmessages_1.NETMessages.net_SignonState] = {
    name: "net_SignonState",
    class: netmessages_1.CNETMsgSignonState
};
exports.messages[netmessages_1.NETMessages.net_PlayerAvatarData] = {
    name: "net_PlayerAvatarData",
    class: netmessages_1.CNETMsgPlayerAvatarData
};
exports.messages[netmessages_1.SVCMessages.svc_ServerInfo] = {
    name: "svc_ServerInfo",
    class: netmessages_1.CSVCMsgServerInfo
};
exports.messages[netmessages_1.SVCMessages.svc_SendTable] = {
    name: "svc_SendTable",
    class: netmessages_1.CSVCMsgSendTable
};
exports.messages[netmessages_1.SVCMessages.svc_ClassInfo] = {
    name: "svc_ClassInfo",
    class: netmessages_1.CSVCMsgClassInfo
};
exports.messages[netmessages_1.SVCMessages.svc_SetPause] = {
    name: "svc_SetPause",
    class: netmessages_1.CSVCMsgSetPause
};
exports.messages[netmessages_1.SVCMessages.svc_CreateStringTable] = {
    name: "svc_CreateStringTable",
    class: netmessages_1.CSVCMsgCreateStringTable
};
exports.messages[netmessages_1.SVCMessages.svc_UpdateStringTable] = {
    name: "svc_UpdateStringTable",
    class: netmessages_1.CSVCMsgUpdateStringTable
};
exports.messages[netmessages_1.SVCMessages.svc_VoiceInit] = {
    name: "svc_VoiceInit",
    class: netmessages_1.CSVCMsgVoiceInit
};
exports.messages[netmessages_1.SVCMessages.svc_VoiceData] = {
    name: "svc_VoiceData",
    class: netmessages_1.CSVCMsgVoiceData
};
exports.messages[netmessages_1.SVCMessages.svc_Print] = { name: "svc_Print", class: netmessages_1.CSVCMsgPrint };
exports.messages[netmessages_1.SVCMessages.svc_Sounds] = { name: "svc_Sounds", class: netmessages_1.CSVCMsgSounds };
exports.messages[netmessages_1.SVCMessages.svc_SetView] = {
    name: "svc_SetView",
    class: netmessages_1.CSVCMsgSetView
};
exports.messages[netmessages_1.SVCMessages.svc_FixAngle] = {
    name: "svc_FixAngle",
    class: netmessages_1.CSVCMsgFixAngle
};
exports.messages[netmessages_1.SVCMessages.svc_CrosshairAngle] = {
    name: "svc_CrosshairAngle",
    class: netmessages_1.CSVCMsgCrosshairAngle
};
exports.messages[netmessages_1.SVCMessages.svc_BSPDecal] = {
    name: "svc_BSPDecal",
    class: netmessages_1.CSVCMsgBSPDecal
};
exports.messages[netmessages_1.SVCMessages.svc_SplitScreen] = {
    name: "svc_SplitScreen",
    class: netmessages_1.CSVCMsgSplitScreen
};
exports.messages[netmessages_1.SVCMessages.svc_UserMessage] = {
    name: "svc_UserMessage",
    class: netmessages_1.CSVCMsgUserMessage
};
exports.messages[netmessages_1.SVCMessages.svc_EntityMessage] = {
    name: "svc_EntityMessage",
    class: netmessages_1.CSVCMsgEntityMsg
};
exports.messages[netmessages_1.SVCMessages.svc_GameEvent] = {
    name: "svc_GameEvent",
    class: netmessages_1.CSVCMsgGameEvent
};
exports.messages[netmessages_1.SVCMessages.svc_PacketEntities] = {
    name: "svc_PacketEntities",
    class: netmessages_1.CSVCMsgPacketEntities
};
exports.messages[netmessages_1.SVCMessages.svc_TempEntities] = {
    name: "svc_TempEntities",
    class: netmessages_1.CSVCMsgTempEntities
};
exports.messages[netmessages_1.SVCMessages.svc_Prefetch] = {
    name: "svc_Prefetch",
    class: netmessages_1.CSVCMsgPrefetch
};
exports.messages[netmessages_1.SVCMessages.svc_Menu] = { name: "svc_Menu", class: netmessages_1.CSVCMsgMenu };
exports.messages[netmessages_1.SVCMessages.svc_GameEventList] = {
    name: "svc_GameEventList",
    class: netmessages_1.CSVCMsgGameEventList
};
exports.messages[netmessages_1.SVCMessages.svc_GetCvarValue] = {
    name: "svc_GetCvarValue",
    class: netmessages_1.CSVCMsgGetCvarValue
};
exports.messages[netmessages_1.SVCMessages.svc_PaintmapData] = {
    name: "svc_PaintmapData",
    class: netmessages_1.CSVCMsgPaintmapData
};
exports.messages[netmessages_1.SVCMessages.svc_CmdKeyValues] = {
    name: "svc_CmdKeyValues",
    class: netmessages_1.CSVCMsgCmdKeyValues
};
exports.messages[netmessages_1.SVCMessages.svc_EncryptedData] = {
    name: "svc_EncryptedData",
    class: netmessages_1.CSVCMsgEncryptedData
};
exports.messages[netmessages_1.SVCMessages.svc_HltvReplay] = {
    name: "svc_HltvReplay",
    class: netmessages_1.CSVCMsgHltvReplay
};
exports.messages[netmessages_1.SVCMessages.svc_Broadcast_Command] = {
    name: "svc_Broadcast_Command",
    class: netmessages_1.CSVCMsgBroadcastCommand
};
function findByName(name) {
    return exports.messages.find(descriptor => descriptor.name === name);
}
exports.findByName = findByName;
function findByType(type) {
    return exports.messages[type];
}
exports.findByType = findByType;

},{"./protobufs/netmessages":27}],23:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.makeDecoder = exports.SPROP_VARINT = exports.SPROP_CHANGES_OFTEN = exports.SPROP_CELL_COORD_INTEGRAL = exports.SPROP_CELL_COORD_LOWPRECISION = exports.SPROP_CELL_COORD = exports.SPROP_COORD_MP_INTEGRAL = exports.SPROP_COORD_MP_LOWPRECISION = exports.SPROP_COORD_MP = exports.SPROP_COLLAPSIBLE = exports.SPROP_IS_A_VECTOR_ELEM = exports.SPROP_PROXY_ALWAYS_YES = exports.SPROP_INSIDEARRAY = exports.SPROP_XYZE = exports.SPROP_EXCLUDE = exports.SPROP_NORMAL = exports.SPROP_ROUNDUP = exports.SPROP_ROUNDDOWN = exports.SPROP_NOSCALE = exports.SPROP_COORD = exports.SPROP_UNSIGNED = void 0;
const assert = require("assert");
const Long = require("long");
const assert_exists_1 = require("./assert-exists");
const consts_1 = require("./consts");
const entityhandle_1 = require("./entityhandle");
exports.SPROP_UNSIGNED = 1 << 0; // Unsigned integer data.
exports.SPROP_COORD = 1 << 1; // If this is set, the float/vector is treated like a world coordinate. Note that the bit count is ignored in this case.
exports.SPROP_NOSCALE = 1 << 2; // For floating point, don't scale into range, just take value as is.
exports.SPROP_ROUNDDOWN = 1 << 3; // For floating point, limit high value to range minus one bit unit
exports.SPROP_ROUNDUP = 1 << 4; // For floating point, limit low value to range minus one bit unit
exports.SPROP_NORMAL = 1 << 5; // If this is set, the vector is treated like a normal (only valid for vectors)
exports.SPROP_EXCLUDE = 1 << 6; // This is an exclude prop (not excludED, but it points at another prop to be excluded).
exports.SPROP_XYZE = 1 << 7; // Use XYZ/Exponent encoding for vectors.
exports.SPROP_INSIDEARRAY = 1 << 8; // This tells us that the property is inside an array, so it shouldn't be put into the flattened property list. Its array will point at it when it needs to.
exports.SPROP_PROXY_ALWAYS_YES = 1 << 9; // Set for datatable props using one of the default datatable proxies like SendProxy_DataTableToDataTable that always send the data to all clients.
exports.SPROP_IS_A_VECTOR_ELEM = 1 << 10; // Set automatically if SPROP_VECTORELEM is used.
exports.SPROP_COLLAPSIBLE = 1 << 11; // Set automatically if it's a datatable with an offset of 0 that doesn't change the pointer (ie: for all automatically-chained base classes).
exports.SPROP_COORD_MP = 1 << 12; // Like SPROP_COORD, but special handling for multiplayer games
exports.SPROP_COORD_MP_LOWPRECISION = 1 << 13; // Like SPROP_COORD, but special handling for multiplayer games where the fractional component only gets a 3 bits instead of 5
exports.SPROP_COORD_MP_INTEGRAL = 1 << 14; // SPROP_COORD_MP, but coordinates are rounded to integral boundaries
exports.SPROP_CELL_COORD = 1 << 15; // Like SPROP_COORD, but special encoding for cell coordinates that can't be negative, bit count indicate maximum value
exports.SPROP_CELL_COORD_LOWPRECISION = 1 << 16; // Like SPROP_CELL_COORD, but special handling where the fractional component only gets a 3 bits instead of 5
exports.SPROP_CELL_COORD_INTEGRAL = 1 << 17; // SPROP_CELL_COORD, but coordinates are rounded to integral boundaries
exports.SPROP_CHANGES_OFTEN = 1 << 18; // this is an often changed field, moved to head of sendtable so it gets a small index
exports.SPROP_VARINT = 1 << 19; // use var int encoded (google protobuf style), note you want to include SPROP_UNSIGNED if needed, its more efficient
const DT_MAX_STRING_BITS = 9;
function makeIntDecoder(sendProp) {
    if ((sendProp.flags & exports.SPROP_VARINT) !== 0) {
        if ((sendProp.flags & exports.SPROP_UNSIGNED) !== 0) {
            return bitbuf => bitbuf.readUVarInt32();
        }
        else {
            return bitbuf => bitbuf.readVarInt32();
        }
    }
    else {
        const numBits = sendProp.numBits;
        if ((sendProp.flags & exports.SPROP_UNSIGNED) !== 0) {
            if ((sendProp.flags & exports.SPROP_NOSCALE) !== 0 &&
                sendProp.numBits === consts_1.NUM_NETWORKED_EHANDLE_BITS) {
                return bitbuf => new entityhandle_1.EntityHandle(bitbuf.readUBits(numBits));
            }
            else if (numBits === 1) {
                return bitbuf => bitbuf.readOneBit();
            }
            else {
                return bitbuf => bitbuf.readUBits(numBits);
            }
        }
        else {
            return bitbuf => bitbuf.readSBits(numBits);
        }
    }
}
function makeSpecialFloatDecoder(sendProp) {
    if ((sendProp.flags & exports.SPROP_COORD) !== 0) {
        return bitbuf => bitbuf.readBitCoord();
    }
    else if ((sendProp.flags & exports.SPROP_COORD_MP) !== 0) {
        return bitbuf => bitbuf.readBitCoordMPNone();
    }
    else if ((sendProp.flags & exports.SPROP_COORD_MP_LOWPRECISION) !== 0) {
        return bitbuf => bitbuf.readBitCoordMPLowPrecision();
    }
    else if ((sendProp.flags & exports.SPROP_COORD_MP_INTEGRAL) !== 0) {
        return bitbuf => bitbuf.readBitCoordMPIntegral();
    }
    else if ((sendProp.flags & exports.SPROP_NOSCALE) !== 0) {
        return bitbuf => bitbuf.readFloat32();
    }
    else if ((sendProp.flags & exports.SPROP_NORMAL) !== 0) {
        return bitbuf => bitbuf.readBitNormal();
    }
    else if ((sendProp.flags & exports.SPROP_CELL_COORD) !== 0) {
        return bitbuf => bitbuf.readBitCellCoordNone(sendProp.numBits);
    }
    else if ((sendProp.flags & exports.SPROP_CELL_COORD_LOWPRECISION) !== 0) {
        return bitbuf => bitbuf.readBitCellCoordLowPrecision(sendProp.numBits);
    }
    else if ((sendProp.flags & exports.SPROP_CELL_COORD_INTEGRAL) !== 0) {
        return bitbuf => bitbuf.readUBits(sendProp.numBits);
    }
    else {
        return undefined;
    }
}
function makeFloatDecoder(sendProp) {
    const special = makeSpecialFloatDecoder(sendProp);
    if (special !== undefined) {
        return special;
    }
    const numBits = sendProp.numBits;
    const maxValue = (1 << numBits) - 1;
    const lowValue = sendProp.lowValue;
    const highValue = sendProp.highValue;
    return bitbuf => {
        const interp = bitbuf.readUBits(numBits);
        const fVal = interp / maxValue;
        return lowValue + (highValue - lowValue) * fVal;
    };
}
function makeVectorDecoder(sendProp) {
    const floatDecode = makeFloatDecoder(sendProp);
    const isNormal = (sendProp.flags & exports.SPROP_NORMAL) !== 0;
    if (isNormal) {
        return bitbuf => {
            const v = {
                x: floatDecode(bitbuf),
                y: floatDecode(bitbuf),
                z: 0.0
            };
            const signBit = bitbuf.readOneBit();
            const v0v0v1v1 = v.x * v.x + v.y * v.y;
            if (v0v0v1v1 < 1.0) {
                v.z = Math.sqrt(1.0 - v0v0v1v1);
            }
            else {
                v.z = 0.0;
            }
            if (signBit) {
                v.z *= -1.0;
            }
            return v;
        };
    }
    else {
        return bitbuf => ({
            x: floatDecode(bitbuf),
            y: floatDecode(bitbuf),
            z: floatDecode(bitbuf)
        });
    }
}
function makeVectorXYDecoder(sendProp) {
    const floatDecode = makeFloatDecoder(sendProp);
    return bitbuf => ({
        x: floatDecode(bitbuf),
        y: floatDecode(bitbuf),
        z: 0.0
    });
}
function makeStringDecoder(_sendProp) {
    return bitbuf => {
        const len = bitbuf.readUBits(DT_MAX_STRING_BITS);
        return bitbuf.readString(len);
    };
}
function makeInt64Decoder(sendProp) {
    if ((sendProp.flags & exports.SPROP_VARINT) !== 0) {
        if ((sendProp.flags & exports.SPROP_UNSIGNED) !== 0) {
            throw new Error("64-bit unsigned varint not implemented"); // TODO
        }
        else {
            throw new Error("64-bit signed varint not implemented"); // TODO
        }
    }
    else {
        const highBits = sendProp.numBits - 32;
        if ((sendProp.flags & exports.SPROP_UNSIGNED) !== 0) {
            return bitbuf => {
                const lowInt = bitbuf.readUBits(32);
                const highInt = bitbuf.readUBits(highBits);
                return Long.fromBits(lowInt, highInt, false);
            };
        }
        else {
            return bitbuf => {
                const neg = bitbuf.readOneBit();
                const lowInt = bitbuf.readUBits(32);
                const highInt = bitbuf.readUBits(highBits - 1);
                return Long.fromBits(lowInt, highInt, !neg);
            };
        }
    }
}
function makeValueDecoder(sendProp) {
    switch (sendProp.type) {
        case 0 /* PropType.Int */:
            return makeIntDecoder(sendProp);
        case 1 /* PropType.Float */:
            return makeFloatDecoder(sendProp);
        case 2 /* PropType.Vector */:
            return makeVectorDecoder(sendProp);
        case 3 /* PropType.VectorXY */:
            return makeVectorXYDecoder(sendProp);
        case 4 /* PropType.String */:
            return makeStringDecoder(sendProp);
        case 7 /* PropType.Int64 */:
            return makeInt64Decoder(sendProp);
        default:
            throw new Error(`Unsupported send prop type ${sendProp.type}`);
    }
}
function makeArrayDecoder(sendProp, arrayElementProp) {
    const maxElements = sendProp.numElements;
    const numBits = (Math.log2(maxElements) | 0) + 1;
    const elementDecoder = makeValueDecoder(arrayElementProp);
    return bitbuf => {
        const numElements = bitbuf.readUBits(numBits);
        const array = new Array(numElements);
        for (let i = 0; i < numElements; ++i) {
            array[i] = elementDecoder(bitbuf);
        }
        return array;
    };
}
function makeDecoder(sendProp, arrayElementProp) {
    const type = sendProp.type;
    assert(type !== 6 /* PropType.DataTable */);
    if (type === 5 /* PropType.Array */) {
        return makeArrayDecoder(sendProp, (0, assert_exists_1.default)(arrayElementProp, "array prop with no element prop"));
    }
    else {
        return makeValueDecoder(sendProp);
    }
}
exports.makeDecoder = makeDecoder;

},{"./assert-exists":2,"./consts":3,"./entityhandle":16,"assert":73,"long":712}],24:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CMsgGCCStrike15V2MatchmakingServerRoundStats_DropInfo = exports.CMsgGCCStrike15V2MatchmakingServerRoundStats = exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve = exports.CMsgGCCStrike15V2MatchmakingServerReservationResponse = exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve = exports.CPreMatchInfoData_TeamStats = exports.CPreMatchInfoData = exports.CDataGCCStrike15V2TournamentMatchDraft_Entry = exports.CDataGCCStrike15V2TournamentMatchDraft = exports.CMsgGCCStrike15V2MatchmakingGC2ClientUpdate_Note = exports.CMsgGCCStrike15V2MatchmakingGC2ClientUpdate = exports.CMsgGCCStrike15V2MatchmakingClient2ServerPing = exports.CMsgGCCStrike15V2MatchmakingStop = exports.CMsgGCCStrike15V2MatchmakingStart = exports.CMsgGCCStrike15V2GC2ServerReservationUpdate = exports.CMsgGCCStrike15V2MatchmakingGC2ServerConfirm = exports.CMsgGCCStrike15V2MatchmakingGCOperationalStats = exports.CMsgGCServerQuestUpdateData = exports.DeepPlayerMatchEvent = exports.DeepPlayerStatsEntry = exports.PlayerQuestData_QuestItemData = exports.PlayerQuestData = exports.ScoreLeaderboardData_AccountEntries = exports.ScoreLeaderboardData_Entry = exports.ScoreLeaderboardData = exports.MatchEndItemUpdates = exports.XpProgressData = exports.CMsgCsgoSteamUserStatChange = exports.IpAddressMask = exports.ServerHltvInfo = exports.TournamentMatchSetup = exports.AccountActivity = exports.PlayerMedalsInfo = exports.PlayerCommendationInfo = exports.PlayerRankingInfo = exports.OperationalStatisticsPacket = exports.OperationalStatisticElement = exports.OperationalStatisticDescription = exports.GlobalStatistics = exports.TournamentEvent = exports.TournamentTeam = exports.TournamentPlayer = exports.DetailedSearchStatistic = exports.DataCenterPing = exports.GameServerPing = exports.EInitSystemResult = exports.EClientReportingVersion = exports.ECsgoSteamUserStat = exports.ECsgoGCMsg = exports.protobufPackage = void 0;
exports.CMsgGCCStrike15V2MatchList = exports.CDataGCCStrike15V2TournamentInfo = exports.CDataGCCStrike15V2TournamentSection = exports.CDataGCCStrike15V2TournamentGroup_Picks = exports.CDataGCCStrike15V2TournamentGroup = exports.CDataGCCStrike15V2TournamentGroupTeam = exports.CDataGCCStrike15V2MatchInfo = exports.CMsgGCCStrike15V2MatchListRequestFullGameInfo = exports.CMsgGCCStrike15V2MatchListRequestTournamentGames = exports.CMsgGCCStrike15V2MatchListRequestRecentUserGames = exports.CMsgGCCStrike15V2MatchListRequestLiveGameForUser = exports.CMsgGCCStrike15V2MatchListRequestCurrentLiveGames = exports.CMsgGCCStrike15V2Client2GCEconPreviewDataBlockResponse = exports.CMsgGCCStrike15V2Client2GCEconPreviewDataBlockRequest = exports.CMsgItemAcknowledged = exports.CMsgGCCStrike15V2MatchEndRewardDropsNotification = exports.CEconItemPreviewDataBlock_Sticker = exports.CEconItemPreviewDataBlock = exports.CMsgGCCStrike15V2MatchEndRunRewardDrops = exports.CMsgGCCStrike15V2Client2GCTextMsg = exports.CMsgGCCStrike15V2GC2ClientTextMsg = exports.CClientHeaderOverwatchEvidence = exports.CMsgGCCStrike15V2PlayerOverwatchCaseStatus = exports.CMsgGCCStrike15V2PlayerOverwatchCaseAssignment = exports.CMsgGCCStrike15V2PlayerOverwatchCaseUpdate = exports.CMsgGCCStrike15V2PlayersProfile = exports.CMsgGCCStrike15V2ClientRequestPlayersProfile = exports.CMsgGCCStrike15V2WatchInfoUsers = exports.CMsgGCCStrike15ClientDeepStats_DeepStatsMatch = exports.CMsgGCCStrike15ClientDeepStats_DeepStatsRange = exports.CMsgGCCStrike15ClientDeepStats = exports.CMsgGCCstrike15V2GC2ServerNotifyXPRewarded = exports.CMsgGCCstrike15V2ClientRedeemMissionReward = exports.CMsgGCCstrike15V2ClientRequestNewMission = exports.CMsgGCCStrike15V2ClientRequestJoinServerData = exports.CMsgGCCStrike15V2ClientRequestJoinFriendData = exports.WatchableMatchInfo = exports.CMsgGCCStrike15V2ClientRequestWatchInfoFriends = exports.CMsgGCCStrike15V2ClientReportResponse = exports.CMsgGCCStrike15V2ClientReportServer = exports.CMsgGCCStrike15V2ClientCommendPlayer = exports.CMsgGCCStrike15V2ClientReportPlayer = exports.CMsgGCCStrike15V2ServerNotificationForUserPenalty = exports.CMsgGCCStrike15V2MatchmakingOperator2GCBlogUpdate = exports.CMsgGCCStrike15V2ClientGCRankUpdate = exports.CMsgGCCStrike15V2MatchmakingGC2ClientAbandon = exports.CMsgGCCStrike15V2AccountPrivacySettings_Setting = exports.CMsgGCCStrike15V2AccountPrivacySettings = exports.CMsgGCCStrike15V2MatchmakingGC2ClientHello = exports.CMsgGCCStrike15V2MatchmakingClient2GCHello = void 0;
exports.CMsgGCCStrike15V2ClientPartyWarning = exports.CMsgGCCStrike15V2ClientPartyJoinRelay = exports.CMsgGCCStrike15V2ClientAccountBalance = exports.CMsgGCCStrike15V2ClientRequestSouvenir = exports.CMsgGCCStrike15V2ClientRequestOffers = exports.CMsgGCToClientSteamDatagramTicket = exports.CMsgGCCStrike15V2ClientToGCRequestTicket = exports.CMsgGCCStrike15V2AccountRequestCoPlays_Player = exports.CMsgGCCStrike15V2AccountRequestCoPlays = exports.CMsgGCCStrike15V2PartyInvite = exports.CMsgGCCStrike15V2PartySearchResults_Entry = exports.CMsgGCCStrike15V2PartySearchResults = exports.CMsgGCCStrike15V2PartySearch = exports.CMsgGCCStrike15V2PartyRegister = exports.CMsgGCCStrike15V2ClientPollState = exports.CMsgGCCStrike15V2ClientLogonFatalError = exports.CMsgGCCStrike15V2ClientPlayerDecalSign = exports.PlayerDecalDigitalSignature = exports.CMsgGCCStrike15GotvSyncPacket = exports.CMsgGCCStrike15V2ClientAuthKeyCode = exports.CMsgGCCStrike15V2GCToClientChat = exports.CMsgGCCStrike15V2ClientToGCChat = exports.CMsgGCCStrike15V2ClientToGCRequestElevate = exports.CMsgGCCStrike15V2Client2GCStreamUnlock = exports.CMsgGCCStrike15V2Client2GCRequestPrestigeCoin = exports.CMsgGCCStrike15V2AcknowledgePenalty = exports.CMsgGCGlobalGamePlay = exports.CMsgGCGlobalGameUnsubscribe = exports.CMsgGCGlobalGameSubscribe = exports.CSOPersonaDataPublic = exports.CSOAccountRecurringSubscription = exports.CSOAccountSeasonalOperation = exports.CSOQuestProgress = exports.CSOEconCoupon = exports.CMsgGCCStrike15V2GC2ClientTournamentInfo = exports.CMsgGCCStrike15V2Server2GCClientValidate = exports.CMsgGCCStrike15V2ClientSubmitSurveyVote = exports.CMsgGCCStrike15V2GiftsLeaderboardResponse_GiftLeaderboardEntry = exports.CMsgGCCStrike15V2GiftsLeaderboardResponse = exports.CMsgGCCStrike15V2GiftsLeaderboardRequest = exports.CMsgGCCStrike15V2ServerVarValueNotificationInfo = exports.CMsgGCCStrike15V2ClientVarValueNotificationInfo = exports.CMsgCStrike15Welcome = exports.CAttributeString = exports.CMsgGCCStrike15V2Fantasy_FantasyTeam = exports.CMsgGCCStrike15V2Fantasy_FantasySlot = exports.CMsgGCCStrike15V2Fantasy = exports.CMsgGCCStrike15V2Predictions_GroupMatchTeamPick = exports.CMsgGCCStrike15V2Predictions = exports.CMsgGCCStrike15V2MatchListTournamentOperatorMgmt = void 0;
exports.CMsgGCCStrike15V2GC2ClientInitSystemResponse = exports.CMsgGCCStrike15V2GC2ClientInitSystem = exports.CMsgGCCStrike15V2GC2ClientRequestValidation = exports.CMsgGCCStrike15V2GC2ClientRefuseSecureMode = exports.CMsgGCCStrike15V2ClientReportValidation = exports.CVDiagnostic = exports.CMsgGCCStrike15V2ClientPerfReport_Entry = exports.CMsgGCCStrike15V2ClientPerfReport = exports.CMsgGCCStrike15V2GetEventFavoritesResponse = exports.CMsgGCCStrike15V2GetEventFavoritesRequest = exports.CMsgGCCStrike15V2SetEventFavorite = exports.CMsgGCCStrike15V2ClientPartyWarning_Entry = void 0;
/* eslint-disable */
const minimal_1 = require("protobufjs/minimal");
const Long = require("long");
const engine_gcmessages_1 = require("./engine_gcmessages");
exports.protobufPackage = "";
var ECsgoGCMsg;
(function (ECsgoGCMsg) {
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_Base"] = 9100] = "k_EMsgGCCStrike15_v2_Base";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchmakingStart"] = 9101] = "k_EMsgGCCStrike15_v2_MatchmakingStart";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchmakingStop"] = 9102] = "k_EMsgGCCStrike15_v2_MatchmakingStop";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchmakingClient2ServerPing"] = 9103] = "k_EMsgGCCStrike15_v2_MatchmakingClient2ServerPing";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchmakingGC2ClientUpdate"] = 9104] = "k_EMsgGCCStrike15_v2_MatchmakingGC2ClientUpdate";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchmakingServerReservationResponse"] = 9106] = "k_EMsgGCCStrike15_v2_MatchmakingServerReservationResponse";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchmakingGC2ClientReserve"] = 9107] = "k_EMsgGCCStrike15_v2_MatchmakingGC2ClientReserve";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchmakingClient2GCHello"] = 9109] = "k_EMsgGCCStrike15_v2_MatchmakingClient2GCHello";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchmakingGC2ClientHello"] = 9110] = "k_EMsgGCCStrike15_v2_MatchmakingGC2ClientHello";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchmakingGC2ClientAbandon"] = 9112] = "k_EMsgGCCStrike15_v2_MatchmakingGC2ClientAbandon";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchmakingGCOperationalStats"] = 9115] = "k_EMsgGCCStrike15_v2_MatchmakingGCOperationalStats";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchmakingOperator2GCBlogUpdate"] = 9117] = "k_EMsgGCCStrike15_v2_MatchmakingOperator2GCBlogUpdate";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ServerNotificationForUserPenalty"] = 9118] = "k_EMsgGCCStrike15_v2_ServerNotificationForUserPenalty";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientReportPlayer"] = 9119] = "k_EMsgGCCStrike15_v2_ClientReportPlayer";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientReportServer"] = 9120] = "k_EMsgGCCStrike15_v2_ClientReportServer";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientCommendPlayer"] = 9121] = "k_EMsgGCCStrike15_v2_ClientCommendPlayer";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientReportResponse"] = 9122] = "k_EMsgGCCStrike15_v2_ClientReportResponse";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientCommendPlayerQuery"] = 9123] = "k_EMsgGCCStrike15_v2_ClientCommendPlayerQuery";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientCommendPlayerQueryResponse"] = 9124] = "k_EMsgGCCStrike15_v2_ClientCommendPlayerQueryResponse";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_WatchInfoUsers"] = 9126] = "k_EMsgGCCStrike15_v2_WatchInfoUsers";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientRequestPlayersProfile"] = 9127] = "k_EMsgGCCStrike15_v2_ClientRequestPlayersProfile";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_PlayersProfile"] = 9128] = "k_EMsgGCCStrike15_v2_PlayersProfile";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_PlayerOverwatchCaseUpdate"] = 9131] = "k_EMsgGCCStrike15_v2_PlayerOverwatchCaseUpdate";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_PlayerOverwatchCaseAssignment"] = 9132] = "k_EMsgGCCStrike15_v2_PlayerOverwatchCaseAssignment";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_PlayerOverwatchCaseStatus"] = 9133] = "k_EMsgGCCStrike15_v2_PlayerOverwatchCaseStatus";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_GC2ClientTextMsg"] = 9134] = "k_EMsgGCCStrike15_v2_GC2ClientTextMsg";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_Client2GCTextMsg"] = 9135] = "k_EMsgGCCStrike15_v2_Client2GCTextMsg";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchEndRunRewardDrops"] = 9136] = "k_EMsgGCCStrike15_v2_MatchEndRunRewardDrops";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchEndRewardDropsNotification"] = 9137] = "k_EMsgGCCStrike15_v2_MatchEndRewardDropsNotification";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientRequestWatchInfoFriends2"] = 9138] = "k_EMsgGCCStrike15_v2_ClientRequestWatchInfoFriends2";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchList"] = 9139] = "k_EMsgGCCStrike15_v2_MatchList";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchListRequestCurrentLiveGames"] = 9140] = "k_EMsgGCCStrike15_v2_MatchListRequestCurrentLiveGames";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchListRequestRecentUserGames"] = 9141] = "k_EMsgGCCStrike15_v2_MatchListRequestRecentUserGames";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_GC2ServerReservationUpdate"] = 9142] = "k_EMsgGCCStrike15_v2_GC2ServerReservationUpdate";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientVarValueNotificationInfo"] = 9144] = "k_EMsgGCCStrike15_v2_ClientVarValueNotificationInfo";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchListRequestTournamentGames"] = 9146] = "k_EMsgGCCStrike15_v2_MatchListRequestTournamentGames";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchListRequestFullGameInfo"] = 9147] = "k_EMsgGCCStrike15_v2_MatchListRequestFullGameInfo";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_GiftsLeaderboardRequest"] = 9148] = "k_EMsgGCCStrike15_v2_GiftsLeaderboardRequest";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_GiftsLeaderboardResponse"] = 9149] = "k_EMsgGCCStrike15_v2_GiftsLeaderboardResponse";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ServerVarValueNotificationInfo"] = 9150] = "k_EMsgGCCStrike15_v2_ServerVarValueNotificationInfo";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientSubmitSurveyVote"] = 9152] = "k_EMsgGCCStrike15_v2_ClientSubmitSurveyVote";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_Server2GCClientValidate"] = 9153] = "k_EMsgGCCStrike15_v2_Server2GCClientValidate";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchListRequestLiveGameForUser"] = 9154] = "k_EMsgGCCStrike15_v2_MatchListRequestLiveGameForUser";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_Client2GCEconPreviewDataBlockRequest"] = 9156] = "k_EMsgGCCStrike15_v2_Client2GCEconPreviewDataBlockRequest";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_Client2GCEconPreviewDataBlockResponse"] = 9157] = "k_EMsgGCCStrike15_v2_Client2GCEconPreviewDataBlockResponse";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_AccountPrivacySettings"] = 9158] = "k_EMsgGCCStrike15_v2_AccountPrivacySettings";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_SetMyActivityInfo"] = 9159] = "k_EMsgGCCStrike15_v2_SetMyActivityInfo";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchListRequestTournamentPredictions"] = 9160] = "k_EMsgGCCStrike15_v2_MatchListRequestTournamentPredictions";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchListUploadTournamentPredictions"] = 9161] = "k_EMsgGCCStrike15_v2_MatchListUploadTournamentPredictions";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_DraftSummary"] = 9162] = "k_EMsgGCCStrike15_v2_DraftSummary";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientRequestJoinFriendData"] = 9163] = "k_EMsgGCCStrike15_v2_ClientRequestJoinFriendData";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientRequestJoinServerData"] = 9164] = "k_EMsgGCCStrike15_v2_ClientRequestJoinServerData";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientRequestNewMission"] = 9165] = "k_EMsgGCCStrike15_v2_ClientRequestNewMission";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_GC2ClientTournamentInfo"] = 9167] = "k_EMsgGCCStrike15_v2_GC2ClientTournamentInfo";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGC_GlobalGame_Subscribe"] = 9168] = "k_EMsgGC_GlobalGame_Subscribe";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGC_GlobalGame_Unsubscribe"] = 9169] = "k_EMsgGC_GlobalGame_Unsubscribe";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGC_GlobalGame_Play"] = 9170] = "k_EMsgGC_GlobalGame_Play";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_AcknowledgePenalty"] = 9171] = "k_EMsgGCCStrike15_v2_AcknowledgePenalty";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_Client2GCRequestPrestigeCoin"] = 9172] = "k_EMsgGCCStrike15_v2_Client2GCRequestPrestigeCoin";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_GC2ClientGlobalStats"] = 9173] = "k_EMsgGCCStrike15_v2_GC2ClientGlobalStats";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_Client2GCStreamUnlock"] = 9174] = "k_EMsgGCCStrike15_v2_Client2GCStreamUnlock";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_FantasyRequestClientData"] = 9175] = "k_EMsgGCCStrike15_v2_FantasyRequestClientData";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_FantasyUpdateClientData"] = 9176] = "k_EMsgGCCStrike15_v2_FantasyUpdateClientData";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_GCToClientSteamdatagramTicket"] = 9177] = "k_EMsgGCCStrike15_v2_GCToClientSteamdatagramTicket";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientToGCRequestTicket"] = 9178] = "k_EMsgGCCStrike15_v2_ClientToGCRequestTicket";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientToGCRequestElevate"] = 9179] = "k_EMsgGCCStrike15_v2_ClientToGCRequestElevate";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_GlobalChat"] = 9180] = "k_EMsgGCCStrike15_v2_GlobalChat";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_GlobalChat_Subscribe"] = 9181] = "k_EMsgGCCStrike15_v2_GlobalChat_Subscribe";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_GlobalChat_Unsubscribe"] = 9182] = "k_EMsgGCCStrike15_v2_GlobalChat_Unsubscribe";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientAuthKeyCode"] = 9183] = "k_EMsgGCCStrike15_v2_ClientAuthKeyCode";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_GotvSyncPacket"] = 9184] = "k_EMsgGCCStrike15_v2_GotvSyncPacket";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientPlayerDecalSign"] = 9185] = "k_EMsgGCCStrike15_v2_ClientPlayerDecalSign";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientLogonFatalError"] = 9187] = "k_EMsgGCCStrike15_v2_ClientLogonFatalError";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientPollState"] = 9188] = "k_EMsgGCCStrike15_v2_ClientPollState";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_Party_Register"] = 9189] = "k_EMsgGCCStrike15_v2_Party_Register";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_Party_Unregister"] = 9190] = "k_EMsgGCCStrike15_v2_Party_Unregister";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_Party_Search"] = 9191] = "k_EMsgGCCStrike15_v2_Party_Search";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_Party_Invite"] = 9192] = "k_EMsgGCCStrike15_v2_Party_Invite";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_Account_RequestCoPlays"] = 9193] = "k_EMsgGCCStrike15_v2_Account_RequestCoPlays";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientGCRankUpdate"] = 9194] = "k_EMsgGCCStrike15_v2_ClientGCRankUpdate";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientRequestOffers"] = 9195] = "k_EMsgGCCStrike15_v2_ClientRequestOffers";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientAccountBalance"] = 9196] = "k_EMsgGCCStrike15_v2_ClientAccountBalance";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientPartyJoinRelay"] = 9197] = "k_EMsgGCCStrike15_v2_ClientPartyJoinRelay";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientPartyWarning"] = 9198] = "k_EMsgGCCStrike15_v2_ClientPartyWarning";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_SetEventFavorite"] = 9200] = "k_EMsgGCCStrike15_v2_SetEventFavorite";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_GetEventFavorites_Request"] = 9201] = "k_EMsgGCCStrike15_v2_GetEventFavorites_Request";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientPerfReport"] = 9202] = "k_EMsgGCCStrike15_v2_ClientPerfReport";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_GetEventFavorites_Response"] = 9203] = "k_EMsgGCCStrike15_v2_GetEventFavorites_Response";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientRequestSouvenir"] = 9204] = "k_EMsgGCCStrike15_v2_ClientRequestSouvenir";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientReportValidation"] = 9205] = "k_EMsgGCCStrike15_v2_ClientReportValidation";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_GC2ClientRefuseSecureMode"] = 9206] = "k_EMsgGCCStrike15_v2_GC2ClientRefuseSecureMode";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_GC2ClientRequestValidation"] = 9207] = "k_EMsgGCCStrike15_v2_GC2ClientRequestValidation";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_ClientRedeemMissionReward"] = 9209] = "k_EMsgGCCStrike15_v2_ClientRedeemMissionReward";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_ClientDeepStats"] = 9210] = "k_EMsgGCCStrike15_ClientDeepStats";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_StartAgreementSessionInGame"] = 9211] = "k_EMsgGCCStrike15_StartAgreementSessionInGame";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_GC2ClientInitSystem"] = 9212] = "k_EMsgGCCStrike15_v2_GC2ClientInitSystem";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_GC2ClientInitSystem_Response"] = 9213] = "k_EMsgGCCStrike15_v2_GC2ClientInitSystem_Response";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_PrivateQueues"] = 9214] = "k_EMsgGCCStrike15_v2_PrivateQueues";
    ECsgoGCMsg[ECsgoGCMsg["k_EMsgGCCStrike15_v2_MatchListTournamentOperatorMgmt"] = 9215] = "k_EMsgGCCStrike15_v2_MatchListTournamentOperatorMgmt";
})(ECsgoGCMsg = exports.ECsgoGCMsg || (exports.ECsgoGCMsg = {}));
var ECsgoSteamUserStat;
(function (ECsgoSteamUserStat) {
    ECsgoSteamUserStat[ECsgoSteamUserStat["k_ECsgoSteamUserStat_XpEarnedGames"] = 1] = "k_ECsgoSteamUserStat_XpEarnedGames";
    ECsgoSteamUserStat[ECsgoSteamUserStat["k_ECsgoSteamUserStat_MatchWinsCompetitive"] = 2] = "k_ECsgoSteamUserStat_MatchWinsCompetitive";
    ECsgoSteamUserStat[ECsgoSteamUserStat["k_ECsgoSteamUserStat_SurvivedDangerZone"] = 3] = "k_ECsgoSteamUserStat_SurvivedDangerZone";
})(ECsgoSteamUserStat = exports.ECsgoSteamUserStat || (exports.ECsgoSteamUserStat = {}));
var EClientReportingVersion;
(function (EClientReportingVersion) {
    EClientReportingVersion[EClientReportingVersion["k_EClientReportingVersion_OldVersion"] = 0] = "k_EClientReportingVersion_OldVersion";
    EClientReportingVersion[EClientReportingVersion["k_EClientReportingVersion_BetaVersion"] = 1] = "k_EClientReportingVersion_BetaVersion";
    EClientReportingVersion[EClientReportingVersion["k_EClientReportingVersion_SupportsTrustedMode"] = 2] = "k_EClientReportingVersion_SupportsTrustedMode";
})(EClientReportingVersion = exports.EClientReportingVersion || (exports.EClientReportingVersion = {}));
var EInitSystemResult;
(function (EInitSystemResult) {
    EInitSystemResult[EInitSystemResult["k_EInitSystemResult_Invalid"] = 0] = "k_EInitSystemResult_Invalid";
    EInitSystemResult[EInitSystemResult["k_EInitSystemResult_Success"] = 1] = "k_EInitSystemResult_Success";
    EInitSystemResult[EInitSystemResult["k_EInitSystemResult_None"] = 2] = "k_EInitSystemResult_None";
    EInitSystemResult[EInitSystemResult["k_EInitSystemResult_NotFound"] = 3] = "k_EInitSystemResult_NotFound";
    EInitSystemResult[EInitSystemResult["k_EInitSystemResult_Existing"] = 4] = "k_EInitSystemResult_Existing";
    EInitSystemResult[EInitSystemResult["k_EInitSystemResult_FailedOpen"] = 5] = "k_EInitSystemResult_FailedOpen";
    EInitSystemResult[EInitSystemResult["k_EInitSystemResult_Mismatch"] = 6] = "k_EInitSystemResult_Mismatch";
    EInitSystemResult[EInitSystemResult["k_EInitSystemResult_FailedInit"] = 7] = "k_EInitSystemResult_FailedInit";
    EInitSystemResult[EInitSystemResult["k_EInitSystemResult_Max"] = 8] = "k_EInitSystemResult_Max";
})(EInitSystemResult = exports.EInitSystemResult || (exports.EInitSystemResult = {}));
function createBaseGameServerPing() {
    return { ping: 0, ip: 0, instances: 0 };
}
exports.GameServerPing = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.ping !== 0) {
            writer.uint32(16).int32(message.ping);
        }
        if (message.ip !== 0) {
            writer.uint32(24).uint32(message.ip);
        }
        if (message.instances !== 0) {
            writer.uint32(40).uint32(message.instances);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGameServerPing();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 2:
                    message.ping = reader.int32();
                    break;
                case 3:
                    message.ip = reader.uint32();
                    break;
                case 5:
                    message.instances = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseGameServerPing();
        message.ping = (_a = object.ping) !== null && _a !== void 0 ? _a : 0;
        message.ip = (_b = object.ip) !== null && _b !== void 0 ? _b : 0;
        message.instances = (_c = object.instances) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseDataCenterPing() {
    return { dataCenterId: 0, ping: 0 };
}
exports.DataCenterPing = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.dataCenterId !== 0) {
            writer.uint32(13).fixed32(message.dataCenterId);
        }
        if (message.ping !== 0) {
            writer.uint32(16).sint32(message.ping);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseDataCenterPing();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.dataCenterId = reader.fixed32();
                    break;
                case 2:
                    message.ping = reader.sint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseDataCenterPing();
        message.dataCenterId = (_a = object.dataCenterId) !== null && _a !== void 0 ? _a : 0;
        message.ping = (_b = object.ping) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseDetailedSearchStatistic() {
    return { gameType: 0, searchTimeAvg: 0, playersSearching: 0 };
}
exports.DetailedSearchStatistic = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.gameType !== 0) {
            writer.uint32(8).uint32(message.gameType);
        }
        if (message.searchTimeAvg !== 0) {
            writer.uint32(16).uint32(message.searchTimeAvg);
        }
        if (message.playersSearching !== 0) {
            writer.uint32(32).uint32(message.playersSearching);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseDetailedSearchStatistic();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.gameType = reader.uint32();
                    break;
                case 2:
                    message.searchTimeAvg = reader.uint32();
                    break;
                case 4:
                    message.playersSearching = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseDetailedSearchStatistic();
        message.gameType = (_a = object.gameType) !== null && _a !== void 0 ? _a : 0;
        message.searchTimeAvg = (_b = object.searchTimeAvg) !== null && _b !== void 0 ? _b : 0;
        message.playersSearching = (_c = object.playersSearching) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseTournamentPlayer() {
    return {
        accountId: 0,
        playerNick: "",
        playerName: "",
        playerDob: 0,
        playerFlag: "",
        playerLocation: "",
        playerDesc: ""
    };
}
exports.TournamentPlayer = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountId !== 0) {
            writer.uint32(8).uint32(message.accountId);
        }
        if (message.playerNick !== "") {
            writer.uint32(18).string(message.playerNick);
        }
        if (message.playerName !== "") {
            writer.uint32(26).string(message.playerName);
        }
        if (message.playerDob !== 0) {
            writer.uint32(32).uint32(message.playerDob);
        }
        if (message.playerFlag !== "") {
            writer.uint32(42).string(message.playerFlag);
        }
        if (message.playerLocation !== "") {
            writer.uint32(50).string(message.playerLocation);
        }
        if (message.playerDesc !== "") {
            writer.uint32(58).string(message.playerDesc);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseTournamentPlayer();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountId = reader.uint32();
                    break;
                case 2:
                    message.playerNick = reader.string();
                    break;
                case 3:
                    message.playerName = reader.string();
                    break;
                case 4:
                    message.playerDob = reader.uint32();
                    break;
                case 5:
                    message.playerFlag = reader.string();
                    break;
                case 6:
                    message.playerLocation = reader.string();
                    break;
                case 7:
                    message.playerDesc = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g;
        const message = createBaseTournamentPlayer();
        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;
        message.playerNick = (_b = object.playerNick) !== null && _b !== void 0 ? _b : "";
        message.playerName = (_c = object.playerName) !== null && _c !== void 0 ? _c : "";
        message.playerDob = (_d = object.playerDob) !== null && _d !== void 0 ? _d : 0;
        message.playerFlag = (_e = object.playerFlag) !== null && _e !== void 0 ? _e : "";
        message.playerLocation = (_f = object.playerLocation) !== null && _f !== void 0 ? _f : "";
        message.playerDesc = (_g = object.playerDesc) !== null && _g !== void 0 ? _g : "";
        return message;
    }
};
function createBaseTournamentTeam() {
    return { teamId: 0, teamTag: "", teamFlag: "", teamName: "", players: [] };
}
exports.TournamentTeam = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.teamId !== 0) {
            writer.uint32(8).int32(message.teamId);
        }
        if (message.teamTag !== "") {
            writer.uint32(18).string(message.teamTag);
        }
        if (message.teamFlag !== "") {
            writer.uint32(26).string(message.teamFlag);
        }
        if (message.teamName !== "") {
            writer.uint32(34).string(message.teamName);
        }
        for (const v of message.players) {
            exports.TournamentPlayer.encode(v, writer.uint32(42).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseTournamentTeam();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.teamId = reader.int32();
                    break;
                case 2:
                    message.teamTag = reader.string();
                    break;
                case 3:
                    message.teamFlag = reader.string();
                    break;
                case 4:
                    message.teamName = reader.string();
                    break;
                case 5:
                    message.players.push(exports.TournamentPlayer.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseTournamentTeam();
        message.teamId = (_a = object.teamId) !== null && _a !== void 0 ? _a : 0;
        message.teamTag = (_b = object.teamTag) !== null && _b !== void 0 ? _b : "";
        message.teamFlag = (_c = object.teamFlag) !== null && _c !== void 0 ? _c : "";
        message.teamName = (_d = object.teamName) !== null && _d !== void 0 ? _d : "";
        message.players =
            ((_e = object.players) === null || _e === void 0 ? void 0 : _e.map(e => exports.TournamentPlayer.fromPartial(e))) || [];
        return message;
    }
};
function createBaseTournamentEvent() {
    return {
        eventId: 0,
        eventTag: "",
        eventName: "",
        eventTimeStart: 0,
        eventTimeEnd: 0,
        eventPublic: 0,
        eventStageId: 0,
        eventStageName: "",
        activeSectionId: 0
    };
}
exports.TournamentEvent = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.eventId !== 0) {
            writer.uint32(8).int32(message.eventId);
        }
        if (message.eventTag !== "") {
            writer.uint32(18).string(message.eventTag);
        }
        if (message.eventName !== "") {
            writer.uint32(26).string(message.eventName);
        }
        if (message.eventTimeStart !== 0) {
            writer.uint32(32).uint32(message.eventTimeStart);
        }
        if (message.eventTimeEnd !== 0) {
            writer.uint32(40).uint32(message.eventTimeEnd);
        }
        if (message.eventPublic !== 0) {
            writer.uint32(48).int32(message.eventPublic);
        }
        if (message.eventStageId !== 0) {
            writer.uint32(56).int32(message.eventStageId);
        }
        if (message.eventStageName !== "") {
            writer.uint32(66).string(message.eventStageName);
        }
        if (message.activeSectionId !== 0) {
            writer.uint32(72).uint32(message.activeSectionId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseTournamentEvent();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.eventId = reader.int32();
                    break;
                case 2:
                    message.eventTag = reader.string();
                    break;
                case 3:
                    message.eventName = reader.string();
                    break;
                case 4:
                    message.eventTimeStart = reader.uint32();
                    break;
                case 5:
                    message.eventTimeEnd = reader.uint32();
                    break;
                case 6:
                    message.eventPublic = reader.int32();
                    break;
                case 7:
                    message.eventStageId = reader.int32();
                    break;
                case 8:
                    message.eventStageName = reader.string();
                    break;
                case 9:
                    message.activeSectionId = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
        const message = createBaseTournamentEvent();
        message.eventId = (_a = object.eventId) !== null && _a !== void 0 ? _a : 0;
        message.eventTag = (_b = object.eventTag) !== null && _b !== void 0 ? _b : "";
        message.eventName = (_c = object.eventName) !== null && _c !== void 0 ? _c : "";
        message.eventTimeStart = (_d = object.eventTimeStart) !== null && _d !== void 0 ? _d : 0;
        message.eventTimeEnd = (_e = object.eventTimeEnd) !== null && _e !== void 0 ? _e : 0;
        message.eventPublic = (_f = object.eventPublic) !== null && _f !== void 0 ? _f : 0;
        message.eventStageId = (_g = object.eventStageId) !== null && _g !== void 0 ? _g : 0;
        message.eventStageName = (_h = object.eventStageName) !== null && _h !== void 0 ? _h : "";
        message.activeSectionId = (_j = object.activeSectionId) !== null && _j !== void 0 ? _j : 0;
        return message;
    }
};
function createBaseGlobalStatistics() {
    return {
        playersOnline: 0,
        serversOnline: 0,
        playersSearching: 0,
        serversAvailable: 0,
        ongoingMatches: 0,
        searchTimeAvg: 0,
        searchStatistics: [],
        mainPostUrl: "",
        requiredAppidVersion: 0,
        pricesheetVersion: 0,
        twitchStreamsVersion: 0,
        activeTournamentEventid: 0,
        activeSurveyId: 0,
        rtime32Cur: 0,
        rtime32EventStart: 0
    };
}
exports.GlobalStatistics = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.playersOnline !== 0) {
            writer.uint32(8).uint32(message.playersOnline);
        }
        if (message.serversOnline !== 0) {
            writer.uint32(16).uint32(message.serversOnline);
        }
        if (message.playersSearching !== 0) {
            writer.uint32(24).uint32(message.playersSearching);
        }
        if (message.serversAvailable !== 0) {
            writer.uint32(32).uint32(message.serversAvailable);
        }
        if (message.ongoingMatches !== 0) {
            writer.uint32(40).uint32(message.ongoingMatches);
        }
        if (message.searchTimeAvg !== 0) {
            writer.uint32(48).uint32(message.searchTimeAvg);
        }
        for (const v of message.searchStatistics) {
            exports.DetailedSearchStatistic.encode(v, writer.uint32(58).fork()).ldelim();
        }
        if (message.mainPostUrl !== "") {
            writer.uint32(66).string(message.mainPostUrl);
        }
        if (message.requiredAppidVersion !== 0) {
            writer.uint32(72).uint32(message.requiredAppidVersion);
        }
        if (message.pricesheetVersion !== 0) {
            writer.uint32(80).uint32(message.pricesheetVersion);
        }
        if (message.twitchStreamsVersion !== 0) {
            writer.uint32(88).uint32(message.twitchStreamsVersion);
        }
        if (message.activeTournamentEventid !== 0) {
            writer.uint32(96).uint32(message.activeTournamentEventid);
        }
        if (message.activeSurveyId !== 0) {
            writer.uint32(104).uint32(message.activeSurveyId);
        }
        if (message.rtime32Cur !== 0) {
            writer.uint32(112).uint32(message.rtime32Cur);
        }
        if (message.rtime32EventStart !== 0) {
            writer.uint32(120).uint32(message.rtime32EventStart);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseGlobalStatistics();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.playersOnline = reader.uint32();
                    break;
                case 2:
                    message.serversOnline = reader.uint32();
                    break;
                case 3:
                    message.playersSearching = reader.uint32();
                    break;
                case 4:
                    message.serversAvailable = reader.uint32();
                    break;
                case 5:
                    message.ongoingMatches = reader.uint32();
                    break;
                case 6:
                    message.searchTimeAvg = reader.uint32();
                    break;
                case 7:
                    message.searchStatistics.push(exports.DetailedSearchStatistic.decode(reader, reader.uint32()));
                    break;
                case 8:
                    message.mainPostUrl = reader.string();
                    break;
                case 9:
                    message.requiredAppidVersion = reader.uint32();
                    break;
                case 10:
                    message.pricesheetVersion = reader.uint32();
                    break;
                case 11:
                    message.twitchStreamsVersion = reader.uint32();
                    break;
                case 12:
                    message.activeTournamentEventid = reader.uint32();
                    break;
                case 13:
                    message.activeSurveyId = reader.uint32();
                    break;
                case 14:
                    message.rtime32Cur = reader.uint32();
                    break;
                case 15:
                    message.rtime32EventStart = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
        const message = createBaseGlobalStatistics();
        message.playersOnline = (_a = object.playersOnline) !== null && _a !== void 0 ? _a : 0;
        message.serversOnline = (_b = object.serversOnline) !== null && _b !== void 0 ? _b : 0;
        message.playersSearching = (_c = object.playersSearching) !== null && _c !== void 0 ? _c : 0;
        message.serversAvailable = (_d = object.serversAvailable) !== null && _d !== void 0 ? _d : 0;
        message.ongoingMatches = (_e = object.ongoingMatches) !== null && _e !== void 0 ? _e : 0;
        message.searchTimeAvg = (_f = object.searchTimeAvg) !== null && _f !== void 0 ? _f : 0;
        message.searchStatistics =
            ((_g = object.searchStatistics) === null || _g === void 0 ? void 0 : _g.map(e => exports.DetailedSearchStatistic.fromPartial(e))) || [];
        message.mainPostUrl = (_h = object.mainPostUrl) !== null && _h !== void 0 ? _h : "";
        message.requiredAppidVersion = (_j = object.requiredAppidVersion) !== null && _j !== void 0 ? _j : 0;
        message.pricesheetVersion = (_k = object.pricesheetVersion) !== null && _k !== void 0 ? _k : 0;
        message.twitchStreamsVersion = (_l = object.twitchStreamsVersion) !== null && _l !== void 0 ? _l : 0;
        message.activeTournamentEventid = (_m = object.activeTournamentEventid) !== null && _m !== void 0 ? _m : 0;
        message.activeSurveyId = (_o = object.activeSurveyId) !== null && _o !== void 0 ? _o : 0;
        message.rtime32Cur = (_p = object.rtime32Cur) !== null && _p !== void 0 ? _p : 0;
        message.rtime32EventStart = (_q = object.rtime32EventStart) !== null && _q !== void 0 ? _q : 0;
        return message;
    }
};
function createBaseOperationalStatisticDescription() {
    return { name: "", idkey: 0 };
}
exports.OperationalStatisticDescription = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.name !== "") {
            writer.uint32(10).string(message.name);
        }
        if (message.idkey !== 0) {
            writer.uint32(16).uint32(message.idkey);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseOperationalStatisticDescription();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.name = reader.string();
                    break;
                case 2:
                    message.idkey = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseOperationalStatisticDescription();
        message.name = (_a = object.name) !== null && _a !== void 0 ? _a : "";
        message.idkey = (_b = object.idkey) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseOperationalStatisticElement() {
    return { idkey: 0, values: [] };
}
exports.OperationalStatisticElement = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.idkey !== 0) {
            writer.uint32(8).uint32(message.idkey);
        }
        writer.uint32(18).fork();
        for (const v of message.values) {
            writer.int32(v);
        }
        writer.ldelim();
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseOperationalStatisticElement();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.idkey = reader.uint32();
                    break;
                case 2:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.values.push(reader.int32());
                        }
                    }
                    else {
                        message.values.push(reader.int32());
                    }
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseOperationalStatisticElement();
        message.idkey = (_a = object.idkey) !== null && _a !== void 0 ? _a : 0;
        message.values = ((_b = object.values) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];
        return message;
    }
};
function createBaseOperationalStatisticsPacket() {
    return { packetid: 0, mstimestamp: 0, values: [] };
}
exports.OperationalStatisticsPacket = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.packetid !== 0) {
            writer.uint32(8).int32(message.packetid);
        }
        if (message.mstimestamp !== 0) {
            writer.uint32(16).int32(message.mstimestamp);
        }
        for (const v of message.values) {
            exports.OperationalStatisticElement.encode(v, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseOperationalStatisticsPacket();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.packetid = reader.int32();
                    break;
                case 2:
                    message.mstimestamp = reader.int32();
                    break;
                case 3:
                    message.values.push(exports.OperationalStatisticElement.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseOperationalStatisticsPacket();
        message.packetid = (_a = object.packetid) !== null && _a !== void 0 ? _a : 0;
        message.mstimestamp = (_b = object.mstimestamp) !== null && _b !== void 0 ? _b : 0;
        message.values =
            ((_c = object.values) === null || _c === void 0 ? void 0 : _c.map(e => exports.OperationalStatisticElement.fromPartial(e))) || [];
        return message;
    }
};
function createBasePlayerRankingInfo() {
    return {
        accountId: 0,
        rankId: 0,
        wins: 0,
        rankChange: 0,
        rankTypeId: 0,
        tvControl: 0
    };
}
exports.PlayerRankingInfo = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountId !== 0) {
            writer.uint32(8).uint32(message.accountId);
        }
        if (message.rankId !== 0) {
            writer.uint32(16).uint32(message.rankId);
        }
        if (message.wins !== 0) {
            writer.uint32(24).uint32(message.wins);
        }
        if (message.rankChange !== 0) {
            writer.uint32(37).float(message.rankChange);
        }
        if (message.rankTypeId !== 0) {
            writer.uint32(48).uint32(message.rankTypeId);
        }
        if (message.tvControl !== 0) {
            writer.uint32(56).uint32(message.tvControl);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBasePlayerRankingInfo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountId = reader.uint32();
                    break;
                case 2:
                    message.rankId = reader.uint32();
                    break;
                case 3:
                    message.wins = reader.uint32();
                    break;
                case 4:
                    message.rankChange = reader.float();
                    break;
                case 6:
                    message.rankTypeId = reader.uint32();
                    break;
                case 7:
                    message.tvControl = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f;
        const message = createBasePlayerRankingInfo();
        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;
        message.rankId = (_b = object.rankId) !== null && _b !== void 0 ? _b : 0;
        message.wins = (_c = object.wins) !== null && _c !== void 0 ? _c : 0;
        message.rankChange = (_d = object.rankChange) !== null && _d !== void 0 ? _d : 0;
        message.rankTypeId = (_e = object.rankTypeId) !== null && _e !== void 0 ? _e : 0;
        message.tvControl = (_f = object.tvControl) !== null && _f !== void 0 ? _f : 0;
        return message;
    }
};
function createBasePlayerCommendationInfo() {
    return { cmdFriendly: 0, cmdTeaching: 0, cmdLeader: 0 };
}
exports.PlayerCommendationInfo = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.cmdFriendly !== 0) {
            writer.uint32(8).uint32(message.cmdFriendly);
        }
        if (message.cmdTeaching !== 0) {
            writer.uint32(16).uint32(message.cmdTeaching);
        }
        if (message.cmdLeader !== 0) {
            writer.uint32(32).uint32(message.cmdLeader);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBasePlayerCommendationInfo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.cmdFriendly = reader.uint32();
                    break;
                case 2:
                    message.cmdTeaching = reader.uint32();
                    break;
                case 4:
                    message.cmdLeader = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBasePlayerCommendationInfo();
        message.cmdFriendly = (_a = object.cmdFriendly) !== null && _a !== void 0 ? _a : 0;
        message.cmdTeaching = (_b = object.cmdTeaching) !== null && _b !== void 0 ? _b : 0;
        message.cmdLeader = (_c = object.cmdLeader) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBasePlayerMedalsInfo() {
    return { displayItemsDefidx: [], featuredDisplayItemDefidx: 0 };
}
exports.PlayerMedalsInfo = {
    encode(message, writer = minimal_1.Writer.create()) {
        writer.uint32(58).fork();
        for (const v of message.displayItemsDefidx) {
            writer.uint32(v);
        }
        writer.ldelim();
        if (message.featuredDisplayItemDefidx !== 0) {
            writer.uint32(64).uint32(message.featuredDisplayItemDefidx);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBasePlayerMedalsInfo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 7:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.displayItemsDefidx.push(reader.uint32());
                        }
                    }
                    else {
                        message.displayItemsDefidx.push(reader.uint32());
                    }
                    break;
                case 8:
                    message.featuredDisplayItemDefidx = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBasePlayerMedalsInfo();
        message.displayItemsDefidx = ((_a = object.displayItemsDefidx) === null || _a === void 0 ? void 0 : _a.map(e => e)) || [];
        message.featuredDisplayItemDefidx = (_b = object.featuredDisplayItemDefidx) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseAccountActivity() {
    return { activity: 0, mode: 0, map: 0, matchid: Long.UZERO };
}
exports.AccountActivity = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.activity !== 0) {
            writer.uint32(8).uint32(message.activity);
        }
        if (message.mode !== 0) {
            writer.uint32(16).uint32(message.mode);
        }
        if (message.map !== 0) {
            writer.uint32(24).uint32(message.map);
        }
        if (!message.matchid.isZero()) {
            writer.uint32(32).uint64(message.matchid);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseAccountActivity();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.activity = reader.uint32();
                    break;
                case 2:
                    message.mode = reader.uint32();
                    break;
                case 3:
                    message.map = reader.uint32();
                    break;
                case 4:
                    message.matchid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseAccountActivity();
        message.activity = (_a = object.activity) !== null && _a !== void 0 ? _a : 0;
        message.mode = (_b = object.mode) !== null && _b !== void 0 ? _b : 0;
        message.map = (_c = object.map) !== null && _c !== void 0 ? _c : 0;
        message.matchid =
            object.matchid !== undefined && object.matchid !== null
                ? Long.fromValue(object.matchid)
                : Long.UZERO;
        return message;
    }
};
function createBaseTournamentMatchSetup() {
    return { eventId: 0, teamIdCt: 0, teamIdT: 0, eventStageId: 0 };
}
exports.TournamentMatchSetup = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.eventId !== 0) {
            writer.uint32(8).int32(message.eventId);
        }
        if (message.teamIdCt !== 0) {
            writer.uint32(16).int32(message.teamIdCt);
        }
        if (message.teamIdT !== 0) {
            writer.uint32(24).int32(message.teamIdT);
        }
        if (message.eventStageId !== 0) {
            writer.uint32(32).int32(message.eventStageId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseTournamentMatchSetup();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.eventId = reader.int32();
                    break;
                case 2:
                    message.teamIdCt = reader.int32();
                    break;
                case 3:
                    message.teamIdT = reader.int32();
                    break;
                case 4:
                    message.eventStageId = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseTournamentMatchSetup();
        message.eventId = (_a = object.eventId) !== null && _a !== void 0 ? _a : 0;
        message.teamIdCt = (_b = object.teamIdCt) !== null && _b !== void 0 ? _b : 0;
        message.teamIdT = (_c = object.teamIdT) !== null && _c !== void 0 ? _c : 0;
        message.eventStageId = (_d = object.eventStageId) !== null && _d !== void 0 ? _d : 0;
        return message;
    }
};
function createBaseServerHltvInfo() {
    return {
        tvUdpPort: 0,
        tvWatchKey: Long.UZERO,
        tvSlots: 0,
        tvClients: 0,
        tvProxies: 0,
        tvTime: 0,
        gameType: 0,
        gameMapgroup: "",
        gameMap: "",
        tvMasterSteamid: Long.UZERO,
        tvLocalSlots: 0,
        tvLocalClients: 0,
        tvLocalProxies: 0,
        tvRelaySlots: 0,
        tvRelayClients: 0,
        tvRelayProxies: 0,
        tvRelayAddress: 0,
        tvRelayPort: 0,
        tvRelaySteamid: Long.UZERO,
        flags: 0
    };
}
exports.ServerHltvInfo = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.tvUdpPort !== 0) {
            writer.uint32(8).uint32(message.tvUdpPort);
        }
        if (!message.tvWatchKey.isZero()) {
            writer.uint32(16).uint64(message.tvWatchKey);
        }
        if (message.tvSlots !== 0) {
            writer.uint32(24).uint32(message.tvSlots);
        }
        if (message.tvClients !== 0) {
            writer.uint32(32).uint32(message.tvClients);
        }
        if (message.tvProxies !== 0) {
            writer.uint32(40).uint32(message.tvProxies);
        }
        if (message.tvTime !== 0) {
            writer.uint32(48).uint32(message.tvTime);
        }
        if (message.gameType !== 0) {
            writer.uint32(64).uint32(message.gameType);
        }
        if (message.gameMapgroup !== "") {
            writer.uint32(74).string(message.gameMapgroup);
        }
        if (message.gameMap !== "") {
            writer.uint32(82).string(message.gameMap);
        }
        if (!message.tvMasterSteamid.isZero()) {
            writer.uint32(88).uint64(message.tvMasterSteamid);
        }
        if (message.tvLocalSlots !== 0) {
            writer.uint32(96).uint32(message.tvLocalSlots);
        }
        if (message.tvLocalClients !== 0) {
            writer.uint32(104).uint32(message.tvLocalClients);
        }
        if (message.tvLocalProxies !== 0) {
            writer.uint32(112).uint32(message.tvLocalProxies);
        }
        if (message.tvRelaySlots !== 0) {
            writer.uint32(120).uint32(message.tvRelaySlots);
        }
        if (message.tvRelayClients !== 0) {
            writer.uint32(128).uint32(message.tvRelayClients);
        }
        if (message.tvRelayProxies !== 0) {
            writer.uint32(136).uint32(message.tvRelayProxies);
        }
        if (message.tvRelayAddress !== 0) {
            writer.uint32(144).uint32(message.tvRelayAddress);
        }
        if (message.tvRelayPort !== 0) {
            writer.uint32(152).uint32(message.tvRelayPort);
        }
        if (!message.tvRelaySteamid.isZero()) {
            writer.uint32(160).uint64(message.tvRelaySteamid);
        }
        if (message.flags !== 0) {
            writer.uint32(168).uint32(message.flags);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseServerHltvInfo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tvUdpPort = reader.uint32();
                    break;
                case 2:
                    message.tvWatchKey = reader.uint64();
                    break;
                case 3:
                    message.tvSlots = reader.uint32();
                    break;
                case 4:
                    message.tvClients = reader.uint32();
                    break;
                case 5:
                    message.tvProxies = reader.uint32();
                    break;
                case 6:
                    message.tvTime = reader.uint32();
                    break;
                case 8:
                    message.gameType = reader.uint32();
                    break;
                case 9:
                    message.gameMapgroup = reader.string();
                    break;
                case 10:
                    message.gameMap = reader.string();
                    break;
                case 11:
                    message.tvMasterSteamid = reader.uint64();
                    break;
                case 12:
                    message.tvLocalSlots = reader.uint32();
                    break;
                case 13:
                    message.tvLocalClients = reader.uint32();
                    break;
                case 14:
                    message.tvLocalProxies = reader.uint32();
                    break;
                case 15:
                    message.tvRelaySlots = reader.uint32();
                    break;
                case 16:
                    message.tvRelayClients = reader.uint32();
                    break;
                case 17:
                    message.tvRelayProxies = reader.uint32();
                    break;
                case 18:
                    message.tvRelayAddress = reader.uint32();
                    break;
                case 19:
                    message.tvRelayPort = reader.uint32();
                    break;
                case 20:
                    message.tvRelaySteamid = reader.uint64();
                    break;
                case 21:
                    message.flags = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
        const message = createBaseServerHltvInfo();
        message.tvUdpPort = (_a = object.tvUdpPort) !== null && _a !== void 0 ? _a : 0;
        message.tvWatchKey =
            object.tvWatchKey !== undefined && object.tvWatchKey !== null
                ? Long.fromValue(object.tvWatchKey)
                : Long.UZERO;
        message.tvSlots = (_b = object.tvSlots) !== null && _b !== void 0 ? _b : 0;
        message.tvClients = (_c = object.tvClients) !== null && _c !== void 0 ? _c : 0;
        message.tvProxies = (_d = object.tvProxies) !== null && _d !== void 0 ? _d : 0;
        message.tvTime = (_e = object.tvTime) !== null && _e !== void 0 ? _e : 0;
        message.gameType = (_f = object.gameType) !== null && _f !== void 0 ? _f : 0;
        message.gameMapgroup = (_g = object.gameMapgroup) !== null && _g !== void 0 ? _g : "";
        message.gameMap = (_h = object.gameMap) !== null && _h !== void 0 ? _h : "";
        message.tvMasterSteamid =
            object.tvMasterSteamid !== undefined && object.tvMasterSteamid !== null
                ? Long.fromValue(object.tvMasterSteamid)
                : Long.UZERO;
        message.tvLocalSlots = (_j = object.tvLocalSlots) !== null && _j !== void 0 ? _j : 0;
        message.tvLocalClients = (_k = object.tvLocalClients) !== null && _k !== void 0 ? _k : 0;
        message.tvLocalProxies = (_l = object.tvLocalProxies) !== null && _l !== void 0 ? _l : 0;
        message.tvRelaySlots = (_m = object.tvRelaySlots) !== null && _m !== void 0 ? _m : 0;
        message.tvRelayClients = (_o = object.tvRelayClients) !== null && _o !== void 0 ? _o : 0;
        message.tvRelayProxies = (_p = object.tvRelayProxies) !== null && _p !== void 0 ? _p : 0;
        message.tvRelayAddress = (_q = object.tvRelayAddress) !== null && _q !== void 0 ? _q : 0;
        message.tvRelayPort = (_r = object.tvRelayPort) !== null && _r !== void 0 ? _r : 0;
        message.tvRelaySteamid =
            object.tvRelaySteamid !== undefined && object.tvRelaySteamid !== null
                ? Long.fromValue(object.tvRelaySteamid)
                : Long.UZERO;
        message.flags = (_s = object.flags) !== null && _s !== void 0 ? _s : 0;
        return message;
    }
};
function createBaseIpAddressMask() {
    return { a: 0, b: 0, c: 0, d: 0, bits: 0, token: 0 };
}
exports.IpAddressMask = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.a !== 0) {
            writer.uint32(8).uint32(message.a);
        }
        if (message.b !== 0) {
            writer.uint32(16).uint32(message.b);
        }
        if (message.c !== 0) {
            writer.uint32(24).uint32(message.c);
        }
        if (message.d !== 0) {
            writer.uint32(32).uint32(message.d);
        }
        if (message.bits !== 0) {
            writer.uint32(40).uint32(message.bits);
        }
        if (message.token !== 0) {
            writer.uint32(48).uint32(message.token);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseIpAddressMask();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.a = reader.uint32();
                    break;
                case 2:
                    message.b = reader.uint32();
                    break;
                case 3:
                    message.c = reader.uint32();
                    break;
                case 4:
                    message.d = reader.uint32();
                    break;
                case 5:
                    message.bits = reader.uint32();
                    break;
                case 6:
                    message.token = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f;
        const message = createBaseIpAddressMask();
        message.a = (_a = object.a) !== null && _a !== void 0 ? _a : 0;
        message.b = (_b = object.b) !== null && _b !== void 0 ? _b : 0;
        message.c = (_c = object.c) !== null && _c !== void 0 ? _c : 0;
        message.d = (_d = object.d) !== null && _d !== void 0 ? _d : 0;
        message.bits = (_e = object.bits) !== null && _e !== void 0 ? _e : 0;
        message.token = (_f = object.token) !== null && _f !== void 0 ? _f : 0;
        return message;
    }
};
function createBaseCMsgCsgoSteamUserStatChange() {
    return { ecsgosteamuserstat: 0, delta: 0, absolute: false };
}
exports.CMsgCsgoSteamUserStatChange = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.ecsgosteamuserstat !== 0) {
            writer.uint32(8).int32(message.ecsgosteamuserstat);
        }
        if (message.delta !== 0) {
            writer.uint32(16).int32(message.delta);
        }
        if (message.absolute === true) {
            writer.uint32(24).bool(message.absolute);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgCsgoSteamUserStatChange();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.ecsgosteamuserstat = reader.int32();
                    break;
                case 2:
                    message.delta = reader.int32();
                    break;
                case 3:
                    message.absolute = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCMsgCsgoSteamUserStatChange();
        message.ecsgosteamuserstat = (_a = object.ecsgosteamuserstat) !== null && _a !== void 0 ? _a : 0;
        message.delta = (_b = object.delta) !== null && _b !== void 0 ? _b : 0;
        message.absolute = (_c = object.absolute) !== null && _c !== void 0 ? _c : false;
        return message;
    }
};
function createBaseXpProgressData() {
    return { xpPoints: 0, xpCategory: 0 };
}
exports.XpProgressData = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.xpPoints !== 0) {
            writer.uint32(8).uint32(message.xpPoints);
        }
        if (message.xpCategory !== 0) {
            writer.uint32(16).int32(message.xpCategory);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseXpProgressData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.xpPoints = reader.uint32();
                    break;
                case 2:
                    message.xpCategory = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseXpProgressData();
        message.xpPoints = (_a = object.xpPoints) !== null && _a !== void 0 ? _a : 0;
        message.xpCategory = (_b = object.xpCategory) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseMatchEndItemUpdates() {
    return { itemId: Long.UZERO, itemAttrDefidx: 0, itemAttrDeltaValue: 0 };
}
exports.MatchEndItemUpdates = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.itemId.isZero()) {
            writer.uint32(8).uint64(message.itemId);
        }
        if (message.itemAttrDefidx !== 0) {
            writer.uint32(16).uint32(message.itemAttrDefidx);
        }
        if (message.itemAttrDeltaValue !== 0) {
            writer.uint32(24).uint32(message.itemAttrDeltaValue);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseMatchEndItemUpdates();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.itemId = reader.uint64();
                    break;
                case 2:
                    message.itemAttrDefidx = reader.uint32();
                    break;
                case 3:
                    message.itemAttrDeltaValue = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseMatchEndItemUpdates();
        message.itemId =
            object.itemId !== undefined && object.itemId !== null
                ? Long.fromValue(object.itemId)
                : Long.UZERO;
        message.itemAttrDefidx = (_a = object.itemAttrDefidx) !== null && _a !== void 0 ? _a : 0;
        message.itemAttrDeltaValue = (_b = object.itemAttrDeltaValue) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseScoreLeaderboardData() {
    return {
        questId: Long.UZERO,
        score: 0,
        accountentries: [],
        matchentries: []
    };
}
exports.ScoreLeaderboardData = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.questId.isZero()) {
            writer.uint32(8).uint64(message.questId);
        }
        if (message.score !== 0) {
            writer.uint32(16).uint32(message.score);
        }
        for (const v of message.accountentries) {
            exports.ScoreLeaderboardData_AccountEntries.encode(v, writer.uint32(26).fork()).ldelim();
        }
        for (const v of message.matchentries) {
            exports.ScoreLeaderboardData_Entry.encode(v, writer.uint32(42).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseScoreLeaderboardData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.questId = reader.uint64();
                    break;
                case 2:
                    message.score = reader.uint32();
                    break;
                case 3:
                    message.accountentries.push(exports.ScoreLeaderboardData_AccountEntries.decode(reader, reader.uint32()));
                    break;
                case 5:
                    message.matchentries.push(exports.ScoreLeaderboardData_Entry.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseScoreLeaderboardData();
        message.questId =
            object.questId !== undefined && object.questId !== null
                ? Long.fromValue(object.questId)
                : Long.UZERO;
        message.score = (_a = object.score) !== null && _a !== void 0 ? _a : 0;
        message.accountentries =
            ((_b = object.accountentries) === null || _b === void 0 ? void 0 : _b.map(e => exports.ScoreLeaderboardData_AccountEntries.fromPartial(e))) || [];
        message.matchentries =
            ((_c = object.matchentries) === null || _c === void 0 ? void 0 : _c.map(e => exports.ScoreLeaderboardData_Entry.fromPartial(e))) || [];
        return message;
    }
};
function createBaseScoreLeaderboardData_Entry() {
    return { tag: 0, val: 0 };
}
exports.ScoreLeaderboardData_Entry = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.tag !== 0) {
            writer.uint32(8).uint32(message.tag);
        }
        if (message.val !== 0) {
            writer.uint32(16).uint32(message.val);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseScoreLeaderboardData_Entry();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tag = reader.uint32();
                    break;
                case 2:
                    message.val = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseScoreLeaderboardData_Entry();
        message.tag = (_a = object.tag) !== null && _a !== void 0 ? _a : 0;
        message.val = (_b = object.val) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseScoreLeaderboardData_AccountEntries() {
    return { accountid: 0, entries: [] };
}
exports.ScoreLeaderboardData_AccountEntries = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountid !== 0) {
            writer.uint32(8).uint32(message.accountid);
        }
        for (const v of message.entries) {
            exports.ScoreLeaderboardData_Entry.encode(v, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseScoreLeaderboardData_AccountEntries();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountid = reader.uint32();
                    break;
                case 2:
                    message.entries.push(exports.ScoreLeaderboardData_Entry.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseScoreLeaderboardData_AccountEntries();
        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;
        message.entries =
            ((_b = object.entries) === null || _b === void 0 ? void 0 : _b.map(e => exports.ScoreLeaderboardData_Entry.fromPartial(e))) || [];
        return message;
    }
};
function createBasePlayerQuestData() {
    return {
        questerAccountId: 0,
        questItemData: [],
        xpProgressData: [],
        timePlayed: 0,
        mmGameMode: 0,
        itemUpdates: [],
        operationPointsEligible: false,
        userstatchanges: []
    };
}
exports.PlayerQuestData = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.questerAccountId !== 0) {
            writer.uint32(8).uint32(message.questerAccountId);
        }
        for (const v of message.questItemData) {
            exports.PlayerQuestData_QuestItemData.encode(v, writer.uint32(18).fork()).ldelim();
        }
        for (const v of message.xpProgressData) {
            exports.XpProgressData.encode(v, writer.uint32(26).fork()).ldelim();
        }
        if (message.timePlayed !== 0) {
            writer.uint32(32).uint32(message.timePlayed);
        }
        if (message.mmGameMode !== 0) {
            writer.uint32(40).uint32(message.mmGameMode);
        }
        for (const v of message.itemUpdates) {
            exports.MatchEndItemUpdates.encode(v, writer.uint32(50).fork()).ldelim();
        }
        if (message.operationPointsEligible === true) {
            writer.uint32(56).bool(message.operationPointsEligible);
        }
        for (const v of message.userstatchanges) {
            exports.CMsgCsgoSteamUserStatChange.encode(v, writer.uint32(66).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBasePlayerQuestData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.questerAccountId = reader.uint32();
                    break;
                case 2:
                    message.questItemData.push(exports.PlayerQuestData_QuestItemData.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.xpProgressData.push(exports.XpProgressData.decode(reader, reader.uint32()));
                    break;
                case 4:
                    message.timePlayed = reader.uint32();
                    break;
                case 5:
                    message.mmGameMode = reader.uint32();
                    break;
                case 6:
                    message.itemUpdates.push(exports.MatchEndItemUpdates.decode(reader, reader.uint32()));
                    break;
                case 7:
                    message.operationPointsEligible = reader.bool();
                    break;
                case 8:
                    message.userstatchanges.push(exports.CMsgCsgoSteamUserStatChange.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h;
        const message = createBasePlayerQuestData();
        message.questerAccountId = (_a = object.questerAccountId) !== null && _a !== void 0 ? _a : 0;
        message.questItemData =
            ((_b = object.questItemData) === null || _b === void 0 ? void 0 : _b.map(e => exports.PlayerQuestData_QuestItemData.fromPartial(e))) || [];
        message.xpProgressData =
            ((_c = object.xpProgressData) === null || _c === void 0 ? void 0 : _c.map(e => exports.XpProgressData.fromPartial(e))) || [];
        message.timePlayed = (_d = object.timePlayed) !== null && _d !== void 0 ? _d : 0;
        message.mmGameMode = (_e = object.mmGameMode) !== null && _e !== void 0 ? _e : 0;
        message.itemUpdates =
            ((_f = object.itemUpdates) === null || _f === void 0 ? void 0 : _f.map(e => exports.MatchEndItemUpdates.fromPartial(e))) || [];
        message.operationPointsEligible = (_g = object.operationPointsEligible) !== null && _g !== void 0 ? _g : false;
        message.userstatchanges =
            ((_h = object.userstatchanges) === null || _h === void 0 ? void 0 : _h.map(e => exports.CMsgCsgoSteamUserStatChange.fromPartial(e))) || [];
        return message;
    }
};
function createBasePlayerQuestData_QuestItemData() {
    return {
        questId: Long.UZERO,
        questNormalPointsEarned: 0,
        questBonusPointsEarned: 0
    };
}
exports.PlayerQuestData_QuestItemData = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.questId.isZero()) {
            writer.uint32(8).uint64(message.questId);
        }
        if (message.questNormalPointsEarned !== 0) {
            writer.uint32(16).int32(message.questNormalPointsEarned);
        }
        if (message.questBonusPointsEarned !== 0) {
            writer.uint32(24).int32(message.questBonusPointsEarned);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBasePlayerQuestData_QuestItemData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.questId = reader.uint64();
                    break;
                case 2:
                    message.questNormalPointsEarned = reader.int32();
                    break;
                case 3:
                    message.questBonusPointsEarned = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBasePlayerQuestData_QuestItemData();
        message.questId =
            object.questId !== undefined && object.questId !== null
                ? Long.fromValue(object.questId)
                : Long.UZERO;
        message.questNormalPointsEarned = (_a = object.questNormalPointsEarned) !== null && _a !== void 0 ? _a : 0;
        message.questBonusPointsEarned = (_b = object.questBonusPointsEarned) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseDeepPlayerStatsEntry() {
    return {
        accountid: 0,
        matchId: Long.UZERO,
        mmGameMode: 0,
        mapid: 0,
        bStartingCt: false,
        matchOutcome: 0,
        roundsWon: 0,
        roundsLost: 0,
        statScore: 0,
        statDeaths: 0,
        statMvps: 0,
        enemyKills: 0,
        enemyHeadshots: 0,
        enemy2ks: 0,
        enemy3ks: 0,
        enemy4ks: 0,
        totalDamage: 0,
        engagementsEntryCount: 0,
        engagementsEntryWins: 0,
        engagements1v1Count: 0,
        engagements1v1Wins: 0,
        engagements1v2Count: 0,
        engagements1v2Wins: 0,
        utilityCount: 0,
        utilitySuccess: 0,
        flashCount: 0,
        flashSuccess: 0,
        mates: []
    };
}
exports.DeepPlayerStatsEntry = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountid !== 0) {
            writer.uint32(8).uint32(message.accountid);
        }
        if (!message.matchId.isZero()) {
            writer.uint32(16).uint64(message.matchId);
        }
        if (message.mmGameMode !== 0) {
            writer.uint32(24).uint32(message.mmGameMode);
        }
        if (message.mapid !== 0) {
            writer.uint32(32).uint32(message.mapid);
        }
        if (message.bStartingCt === true) {
            writer.uint32(40).bool(message.bStartingCt);
        }
        if (message.matchOutcome !== 0) {
            writer.uint32(48).uint32(message.matchOutcome);
        }
        if (message.roundsWon !== 0) {
            writer.uint32(56).uint32(message.roundsWon);
        }
        if (message.roundsLost !== 0) {
            writer.uint32(64).uint32(message.roundsLost);
        }
        if (message.statScore !== 0) {
            writer.uint32(72).uint32(message.statScore);
        }
        if (message.statDeaths !== 0) {
            writer.uint32(96).uint32(message.statDeaths);
        }
        if (message.statMvps !== 0) {
            writer.uint32(104).uint32(message.statMvps);
        }
        if (message.enemyKills !== 0) {
            writer.uint32(112).uint32(message.enemyKills);
        }
        if (message.enemyHeadshots !== 0) {
            writer.uint32(120).uint32(message.enemyHeadshots);
        }
        if (message.enemy2ks !== 0) {
            writer.uint32(128).uint32(message.enemy2ks);
        }
        if (message.enemy3ks !== 0) {
            writer.uint32(136).uint32(message.enemy3ks);
        }
        if (message.enemy4ks !== 0) {
            writer.uint32(144).uint32(message.enemy4ks);
        }
        if (message.totalDamage !== 0) {
            writer.uint32(152).uint32(message.totalDamage);
        }
        if (message.engagementsEntryCount !== 0) {
            writer.uint32(184).uint32(message.engagementsEntryCount);
        }
        if (message.engagementsEntryWins !== 0) {
            writer.uint32(192).uint32(message.engagementsEntryWins);
        }
        if (message.engagements1v1Count !== 0) {
            writer.uint32(200).uint32(message.engagements1v1Count);
        }
        if (message.engagements1v1Wins !== 0) {
            writer.uint32(208).uint32(message.engagements1v1Wins);
        }
        if (message.engagements1v2Count !== 0) {
            writer.uint32(216).uint32(message.engagements1v2Count);
        }
        if (message.engagements1v2Wins !== 0) {
            writer.uint32(224).uint32(message.engagements1v2Wins);
        }
        if (message.utilityCount !== 0) {
            writer.uint32(232).uint32(message.utilityCount);
        }
        if (message.utilitySuccess !== 0) {
            writer.uint32(240).uint32(message.utilitySuccess);
        }
        if (message.flashCount !== 0) {
            writer.uint32(256).uint32(message.flashCount);
        }
        if (message.flashSuccess !== 0) {
            writer.uint32(264).uint32(message.flashSuccess);
        }
        writer.uint32(274).fork();
        for (const v of message.mates) {
            writer.uint32(v);
        }
        writer.ldelim();
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseDeepPlayerStatsEntry();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountid = reader.uint32();
                    break;
                case 2:
                    message.matchId = reader.uint64();
                    break;
                case 3:
                    message.mmGameMode = reader.uint32();
                    break;
                case 4:
                    message.mapid = reader.uint32();
                    break;
                case 5:
                    message.bStartingCt = reader.bool();
                    break;
                case 6:
                    message.matchOutcome = reader.uint32();
                    break;
                case 7:
                    message.roundsWon = reader.uint32();
                    break;
                case 8:
                    message.roundsLost = reader.uint32();
                    break;
                case 9:
                    message.statScore = reader.uint32();
                    break;
                case 12:
                    message.statDeaths = reader.uint32();
                    break;
                case 13:
                    message.statMvps = reader.uint32();
                    break;
                case 14:
                    message.enemyKills = reader.uint32();
                    break;
                case 15:
                    message.enemyHeadshots = reader.uint32();
                    break;
                case 16:
                    message.enemy2ks = reader.uint32();
                    break;
                case 17:
                    message.enemy3ks = reader.uint32();
                    break;
                case 18:
                    message.enemy4ks = reader.uint32();
                    break;
                case 19:
                    message.totalDamage = reader.uint32();
                    break;
                case 23:
                    message.engagementsEntryCount = reader.uint32();
                    break;
                case 24:
                    message.engagementsEntryWins = reader.uint32();
                    break;
                case 25:
                    message.engagements1v1Count = reader.uint32();
                    break;
                case 26:
                    message.engagements1v1Wins = reader.uint32();
                    break;
                case 27:
                    message.engagements1v2Count = reader.uint32();
                    break;
                case 28:
                    message.engagements1v2Wins = reader.uint32();
                    break;
                case 29:
                    message.utilityCount = reader.uint32();
                    break;
                case 30:
                    message.utilitySuccess = reader.uint32();
                    break;
                case 32:
                    message.flashCount = reader.uint32();
                    break;
                case 33:
                    message.flashSuccess = reader.uint32();
                    break;
                case 34:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.mates.push(reader.uint32());
                        }
                    }
                    else {
                        message.mates.push(reader.uint32());
                    }
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2;
        const message = createBaseDeepPlayerStatsEntry();
        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;
        message.matchId =
            object.matchId !== undefined && object.matchId !== null
                ? Long.fromValue(object.matchId)
                : Long.UZERO;
        message.mmGameMode = (_b = object.mmGameMode) !== null && _b !== void 0 ? _b : 0;
        message.mapid = (_c = object.mapid) !== null && _c !== void 0 ? _c : 0;
        message.bStartingCt = (_d = object.bStartingCt) !== null && _d !== void 0 ? _d : false;
        message.matchOutcome = (_e = object.matchOutcome) !== null && _e !== void 0 ? _e : 0;
        message.roundsWon = (_f = object.roundsWon) !== null && _f !== void 0 ? _f : 0;
        message.roundsLost = (_g = object.roundsLost) !== null && _g !== void 0 ? _g : 0;
        message.statScore = (_h = object.statScore) !== null && _h !== void 0 ? _h : 0;
        message.statDeaths = (_j = object.statDeaths) !== null && _j !== void 0 ? _j : 0;
        message.statMvps = (_k = object.statMvps) !== null && _k !== void 0 ? _k : 0;
        message.enemyKills = (_l = object.enemyKills) !== null && _l !== void 0 ? _l : 0;
        message.enemyHeadshots = (_m = object.enemyHeadshots) !== null && _m !== void 0 ? _m : 0;
        message.enemy2ks = (_o = object.enemy2ks) !== null && _o !== void 0 ? _o : 0;
        message.enemy3ks = (_p = object.enemy3ks) !== null && _p !== void 0 ? _p : 0;
        message.enemy4ks = (_q = object.enemy4ks) !== null && _q !== void 0 ? _q : 0;
        message.totalDamage = (_r = object.totalDamage) !== null && _r !== void 0 ? _r : 0;
        message.engagementsEntryCount = (_s = object.engagementsEntryCount) !== null && _s !== void 0 ? _s : 0;
        message.engagementsEntryWins = (_t = object.engagementsEntryWins) !== null && _t !== void 0 ? _t : 0;
        message.engagements1v1Count = (_u = object.engagements1v1Count) !== null && _u !== void 0 ? _u : 0;
        message.engagements1v1Wins = (_v = object.engagements1v1Wins) !== null && _v !== void 0 ? _v : 0;
        message.engagements1v2Count = (_w = object.engagements1v2Count) !== null && _w !== void 0 ? _w : 0;
        message.engagements1v2Wins = (_x = object.engagements1v2Wins) !== null && _x !== void 0 ? _x : 0;
        message.utilityCount = (_y = object.utilityCount) !== null && _y !== void 0 ? _y : 0;
        message.utilitySuccess = (_z = object.utilitySuccess) !== null && _z !== void 0 ? _z : 0;
        message.flashCount = (_0 = object.flashCount) !== null && _0 !== void 0 ? _0 : 0;
        message.flashSuccess = (_1 = object.flashSuccess) !== null && _1 !== void 0 ? _1 : 0;
        message.mates = ((_2 = object.mates) === null || _2 === void 0 ? void 0 : _2.map(e => e)) || [];
        return message;
    }
};
function createBaseDeepPlayerMatchEvent() {
    return {
        accountid: 0,
        matchId: Long.UZERO,
        eventId: 0,
        eventType: 0,
        bPlayingCt: false,
        userPosX: 0,
        userPosY: 0,
        userPosZ: 0,
        userDefidx: 0,
        otherPosX: 0,
        otherPosY: 0,
        otherPosZ: 0,
        otherDefidx: 0,
        eventData: 0
    };
}
exports.DeepPlayerMatchEvent = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountid !== 0) {
            writer.uint32(8).uint32(message.accountid);
        }
        if (!message.matchId.isZero()) {
            writer.uint32(16).uint64(message.matchId);
        }
        if (message.eventId !== 0) {
            writer.uint32(24).uint32(message.eventId);
        }
        if (message.eventType !== 0) {
            writer.uint32(32).uint32(message.eventType);
        }
        if (message.bPlayingCt === true) {
            writer.uint32(40).bool(message.bPlayingCt);
        }
        if (message.userPosX !== 0) {
            writer.uint32(48).int32(message.userPosX);
        }
        if (message.userPosY !== 0) {
            writer.uint32(56).int32(message.userPosY);
        }
        if (message.userPosZ !== 0) {
            writer.uint32(96).int32(message.userPosZ);
        }
        if (message.userDefidx !== 0) {
            writer.uint32(64).uint32(message.userDefidx);
        }
        if (message.otherPosX !== 0) {
            writer.uint32(72).int32(message.otherPosX);
        }
        if (message.otherPosY !== 0) {
            writer.uint32(80).int32(message.otherPosY);
        }
        if (message.otherPosZ !== 0) {
            writer.uint32(104).int32(message.otherPosZ);
        }
        if (message.otherDefidx !== 0) {
            writer.uint32(88).uint32(message.otherDefidx);
        }
        if (message.eventData !== 0) {
            writer.uint32(112).int32(message.eventData);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseDeepPlayerMatchEvent();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountid = reader.uint32();
                    break;
                case 2:
                    message.matchId = reader.uint64();
                    break;
                case 3:
                    message.eventId = reader.uint32();
                    break;
                case 4:
                    message.eventType = reader.uint32();
                    break;
                case 5:
                    message.bPlayingCt = reader.bool();
                    break;
                case 6:
                    message.userPosX = reader.int32();
                    break;
                case 7:
                    message.userPosY = reader.int32();
                    break;
                case 12:
                    message.userPosZ = reader.int32();
                    break;
                case 8:
                    message.userDefidx = reader.uint32();
                    break;
                case 9:
                    message.otherPosX = reader.int32();
                    break;
                case 10:
                    message.otherPosY = reader.int32();
                    break;
                case 13:
                    message.otherPosZ = reader.int32();
                    break;
                case 11:
                    message.otherDefidx = reader.uint32();
                    break;
                case 14:
                    message.eventData = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
        const message = createBaseDeepPlayerMatchEvent();
        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;
        message.matchId =
            object.matchId !== undefined && object.matchId !== null
                ? Long.fromValue(object.matchId)
                : Long.UZERO;
        message.eventId = (_b = object.eventId) !== null && _b !== void 0 ? _b : 0;
        message.eventType = (_c = object.eventType) !== null && _c !== void 0 ? _c : 0;
        message.bPlayingCt = (_d = object.bPlayingCt) !== null && _d !== void 0 ? _d : false;
        message.userPosX = (_e = object.userPosX) !== null && _e !== void 0 ? _e : 0;
        message.userPosY = (_f = object.userPosY) !== null && _f !== void 0 ? _f : 0;
        message.userPosZ = (_g = object.userPosZ) !== null && _g !== void 0 ? _g : 0;
        message.userDefidx = (_h = object.userDefidx) !== null && _h !== void 0 ? _h : 0;
        message.otherPosX = (_j = object.otherPosX) !== null && _j !== void 0 ? _j : 0;
        message.otherPosY = (_k = object.otherPosY) !== null && _k !== void 0 ? _k : 0;
        message.otherPosZ = (_l = object.otherPosZ) !== null && _l !== void 0 ? _l : 0;
        message.otherDefidx = (_m = object.otherDefidx) !== null && _m !== void 0 ? _m : 0;
        message.eventData = (_o = object.eventData) !== null && _o !== void 0 ? _o : 0;
        return message;
    }
};
function createBaseCMsgGCServerQuestUpdateData() {
    return {
        playerQuestData: [],
        binaryData: new Uint8Array(),
        mmGameMode: 0,
        missionlbsdata: undefined
    };
}
exports.CMsgGCServerQuestUpdateData = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.playerQuestData) {
            exports.PlayerQuestData.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.binaryData.length !== 0) {
            writer.uint32(18).bytes(message.binaryData);
        }
        if (message.mmGameMode !== 0) {
            writer.uint32(24).uint32(message.mmGameMode);
        }
        if (message.missionlbsdata !== undefined) {
            exports.ScoreLeaderboardData.encode(message.missionlbsdata, writer.uint32(34).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCServerQuestUpdateData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.playerQuestData.push(exports.PlayerQuestData.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.binaryData = reader.bytes();
                    break;
                case 3:
                    message.mmGameMode = reader.uint32();
                    break;
                case 4:
                    message.missionlbsdata = exports.ScoreLeaderboardData.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCMsgGCServerQuestUpdateData();
        message.playerQuestData =
            ((_a = object.playerQuestData) === null || _a === void 0 ? void 0 : _a.map(e => exports.PlayerQuestData.fromPartial(e))) || [];
        message.binaryData = (_b = object.binaryData) !== null && _b !== void 0 ? _b : new Uint8Array();
        message.mmGameMode = (_c = object.mmGameMode) !== null && _c !== void 0 ? _c : 0;
        message.missionlbsdata =
            object.missionlbsdata !== undefined && object.missionlbsdata !== null
                ? exports.ScoreLeaderboardData.fromPartial(object.missionlbsdata)
                : undefined;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchmakingGCOperationalStats() {
    return { packetid: 0, namekeys: [], packets: [] };
}
exports.CMsgGCCStrike15V2MatchmakingGCOperationalStats = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.packetid !== 0) {
            writer.uint32(8).int32(message.packetid);
        }
        for (const v of message.namekeys) {
            exports.OperationalStatisticDescription.encode(v, writer.uint32(18).fork()).ldelim();
        }
        for (const v of message.packets) {
            exports.OperationalStatisticsPacket.encode(v, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchmakingGCOperationalStats();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.packetid = reader.int32();
                    break;
                case 2:
                    message.namekeys.push(exports.OperationalStatisticDescription.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.packets.push(exports.OperationalStatisticsPacket.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCMsgGCCStrike15V2MatchmakingGCOperationalStats();
        message.packetid = (_a = object.packetid) !== null && _a !== void 0 ? _a : 0;
        message.namekeys =
            ((_b = object.namekeys) === null || _b === void 0 ? void 0 : _b.map(e => exports.OperationalStatisticDescription.fromPartial(e))) || [];
        message.packets =
            ((_c = object.packets) === null || _c === void 0 ? void 0 : _c.map(e => exports.OperationalStatisticsPacket.fromPartial(e))) ||
                [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchmakingGC2ServerConfirm() {
    return { token: 0, stamp: 0, exchange: Long.UZERO };
}
exports.CMsgGCCStrike15V2MatchmakingGC2ServerConfirm = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.token !== 0) {
            writer.uint32(8).uint32(message.token);
        }
        if (message.stamp !== 0) {
            writer.uint32(16).uint32(message.stamp);
        }
        if (!message.exchange.isZero()) {
            writer.uint32(24).uint64(message.exchange);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ServerConfirm();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.token = reader.uint32();
                    break;
                case 2:
                    message.stamp = reader.uint32();
                    break;
                case 3:
                    message.exchange = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ServerConfirm();
        message.token = (_a = object.token) !== null && _a !== void 0 ? _a : 0;
        message.stamp = (_b = object.stamp) !== null && _b !== void 0 ? _b : 0;
        message.exchange =
            object.exchange !== undefined && object.exchange !== null
                ? Long.fromValue(object.exchange)
                : Long.UZERO;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2GC2ServerReservationUpdate() {
    return { viewersExternalTotal: 0, viewersExternalSteam: 0 };
}
exports.CMsgGCCStrike15V2GC2ServerReservationUpdate = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.viewersExternalTotal !== 0) {
            writer.uint32(8).uint32(message.viewersExternalTotal);
        }
        if (message.viewersExternalSteam !== 0) {
            writer.uint32(16).uint32(message.viewersExternalSteam);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2GC2ServerReservationUpdate();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.viewersExternalTotal = reader.uint32();
                    break;
                case 2:
                    message.viewersExternalSteam = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2GC2ServerReservationUpdate();
        message.viewersExternalTotal = (_a = object.viewersExternalTotal) !== null && _a !== void 0 ? _a : 0;
        message.viewersExternalSteam = (_b = object.viewersExternalSteam) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchmakingStart() {
    return {
        accountIds: [],
        gameType: 0,
        ticketData: "",
        clientVersion: 0,
        tournamentMatch: undefined,
        primeOnly: false,
        tvControl: 0,
        lobbyId: Long.UZERO
    };
}
exports.CMsgGCCStrike15V2MatchmakingStart = {
    encode(message, writer = minimal_1.Writer.create()) {
        writer.uint32(10).fork();
        for (const v of message.accountIds) {
            writer.uint32(v);
        }
        writer.ldelim();
        if (message.gameType !== 0) {
            writer.uint32(16).uint32(message.gameType);
        }
        if (message.ticketData !== "") {
            writer.uint32(26).string(message.ticketData);
        }
        if (message.clientVersion !== 0) {
            writer.uint32(32).uint32(message.clientVersion);
        }
        if (message.tournamentMatch !== undefined) {
            exports.TournamentMatchSetup.encode(message.tournamentMatch, writer.uint32(42).fork()).ldelim();
        }
        if (message.primeOnly === true) {
            writer.uint32(48).bool(message.primeOnly);
        }
        if (message.tvControl !== 0) {
            writer.uint32(56).uint32(message.tvControl);
        }
        if (!message.lobbyId.isZero()) {
            writer.uint32(64).uint64(message.lobbyId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchmakingStart();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.accountIds.push(reader.uint32());
                        }
                    }
                    else {
                        message.accountIds.push(reader.uint32());
                    }
                    break;
                case 2:
                    message.gameType = reader.uint32();
                    break;
                case 3:
                    message.ticketData = reader.string();
                    break;
                case 4:
                    message.clientVersion = reader.uint32();
                    break;
                case 5:
                    message.tournamentMatch = exports.TournamentMatchSetup.decode(reader, reader.uint32());
                    break;
                case 6:
                    message.primeOnly = reader.bool();
                    break;
                case 7:
                    message.tvControl = reader.uint32();
                    break;
                case 8:
                    message.lobbyId = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f;
        const message = createBaseCMsgGCCStrike15V2MatchmakingStart();
        message.accountIds = ((_a = object.accountIds) === null || _a === void 0 ? void 0 : _a.map(e => e)) || [];
        message.gameType = (_b = object.gameType) !== null && _b !== void 0 ? _b : 0;
        message.ticketData = (_c = object.ticketData) !== null && _c !== void 0 ? _c : "";
        message.clientVersion = (_d = object.clientVersion) !== null && _d !== void 0 ? _d : 0;
        message.tournamentMatch =
            object.tournamentMatch !== undefined && object.tournamentMatch !== null
                ? exports.TournamentMatchSetup.fromPartial(object.tournamentMatch)
                : undefined;
        message.primeOnly = (_e = object.primeOnly) !== null && _e !== void 0 ? _e : false;
        message.tvControl = (_f = object.tvControl) !== null && _f !== void 0 ? _f : 0;
        message.lobbyId =
            object.lobbyId !== undefined && object.lobbyId !== null
                ? Long.fromValue(object.lobbyId)
                : Long.UZERO;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchmakingStop() {
    return { abandon: 0 };
}
exports.CMsgGCCStrike15V2MatchmakingStop = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.abandon !== 0) {
            writer.uint32(8).int32(message.abandon);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchmakingStop();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.abandon = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2MatchmakingStop();
        message.abandon = (_a = object.abandon) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchmakingClient2ServerPing() {
    return {
        gameserverpings: [],
        offsetIndex: 0,
        finalBatch: 0,
        dataCenterPings: [],
        maxPing: 0,
        testToken: 0
    };
}
exports.CMsgGCCStrike15V2MatchmakingClient2ServerPing = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.gameserverpings) {
            exports.GameServerPing.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.offsetIndex !== 0) {
            writer.uint32(16).int32(message.offsetIndex);
        }
        if (message.finalBatch !== 0) {
            writer.uint32(24).int32(message.finalBatch);
        }
        for (const v of message.dataCenterPings) {
            exports.DataCenterPing.encode(v, writer.uint32(34).fork()).ldelim();
        }
        if (message.maxPing !== 0) {
            writer.uint32(40).uint32(message.maxPing);
        }
        if (message.testToken !== 0) {
            writer.uint32(53).fixed32(message.testToken);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchmakingClient2ServerPing();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.gameserverpings.push(exports.GameServerPing.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.offsetIndex = reader.int32();
                    break;
                case 3:
                    message.finalBatch = reader.int32();
                    break;
                case 4:
                    message.dataCenterPings.push(exports.DataCenterPing.decode(reader, reader.uint32()));
                    break;
                case 5:
                    message.maxPing = reader.uint32();
                    break;
                case 6:
                    message.testToken = reader.fixed32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f;
        const message = createBaseCMsgGCCStrike15V2MatchmakingClient2ServerPing();
        message.gameserverpings =
            ((_a = object.gameserverpings) === null || _a === void 0 ? void 0 : _a.map(e => exports.GameServerPing.fromPartial(e))) || [];
        message.offsetIndex = (_b = object.offsetIndex) !== null && _b !== void 0 ? _b : 0;
        message.finalBatch = (_c = object.finalBatch) !== null && _c !== void 0 ? _c : 0;
        message.dataCenterPings =
            ((_d = object.dataCenterPings) === null || _d === void 0 ? void 0 : _d.map(e => exports.DataCenterPing.fromPartial(e))) || [];
        message.maxPing = (_e = object.maxPing) !== null && _e !== void 0 ? _e : 0;
        message.testToken = (_f = object.testToken) !== null && _f !== void 0 ? _f : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchmakingGC2ClientUpdate() {
    return {
        matchmaking: 0,
        waitingAccountIdSessions: [],
        error: "",
        ongoingmatchAccountIdSessions: [],
        globalStats: undefined,
        failpingAccountIdSessions: [],
        penaltyAccountIdSessions: [],
        failreadyAccountIdSessions: [],
        vacbannedAccountIdSessions: [],
        serverIpaddressMask: undefined,
        notes: [],
        penaltyAccountIdSessionsGreen: [],
        insufficientlevelSessions: [],
        vsncheckAccountIdSessions: [],
        launcherMismatchSessions: [],
        insecureAccountIdSessions: []
    };
}
exports.CMsgGCCStrike15V2MatchmakingGC2ClientUpdate = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.matchmaking !== 0) {
            writer.uint32(8).int32(message.matchmaking);
        }
        writer.uint32(18).fork();
        for (const v of message.waitingAccountIdSessions) {
            writer.uint32(v);
        }
        writer.ldelim();
        if (message.error !== "") {
            writer.uint32(26).string(message.error);
        }
        writer.uint32(50).fork();
        for (const v of message.ongoingmatchAccountIdSessions) {
            writer.uint32(v);
        }
        writer.ldelim();
        if (message.globalStats !== undefined) {
            exports.GlobalStatistics.encode(message.globalStats, writer.uint32(58).fork()).ldelim();
        }
        writer.uint32(66).fork();
        for (const v of message.failpingAccountIdSessions) {
            writer.uint32(v);
        }
        writer.ldelim();
        writer.uint32(74).fork();
        for (const v of message.penaltyAccountIdSessions) {
            writer.uint32(v);
        }
        writer.ldelim();
        writer.uint32(82).fork();
        for (const v of message.failreadyAccountIdSessions) {
            writer.uint32(v);
        }
        writer.ldelim();
        writer.uint32(90).fork();
        for (const v of message.vacbannedAccountIdSessions) {
            writer.uint32(v);
        }
        writer.ldelim();
        if (message.serverIpaddressMask !== undefined) {
            exports.IpAddressMask.encode(message.serverIpaddressMask, writer.uint32(98).fork()).ldelim();
        }
        for (const v of message.notes) {
            exports.CMsgGCCStrike15V2MatchmakingGC2ClientUpdate_Note.encode(v, writer.uint32(106).fork()).ldelim();
        }
        writer.uint32(114).fork();
        for (const v of message.penaltyAccountIdSessionsGreen) {
            writer.uint32(v);
        }
        writer.ldelim();
        writer.uint32(122).fork();
        for (const v of message.insufficientlevelSessions) {
            writer.uint32(v);
        }
        writer.ldelim();
        writer.uint32(130).fork();
        for (const v of message.vsncheckAccountIdSessions) {
            writer.uint32(v);
        }
        writer.ldelim();
        writer.uint32(138).fork();
        for (const v of message.launcherMismatchSessions) {
            writer.uint32(v);
        }
        writer.ldelim();
        writer.uint32(146).fork();
        for (const v of message.insecureAccountIdSessions) {
            writer.uint32(v);
        }
        writer.ldelim();
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientUpdate();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.matchmaking = reader.int32();
                    break;
                case 2:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.waitingAccountIdSessions.push(reader.uint32());
                        }
                    }
                    else {
                        message.waitingAccountIdSessions.push(reader.uint32());
                    }
                    break;
                case 3:
                    message.error = reader.string();
                    break;
                case 6:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.ongoingmatchAccountIdSessions.push(reader.uint32());
                        }
                    }
                    else {
                        message.ongoingmatchAccountIdSessions.push(reader.uint32());
                    }
                    break;
                case 7:
                    message.globalStats = exports.GlobalStatistics.decode(reader, reader.uint32());
                    break;
                case 8:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.failpingAccountIdSessions.push(reader.uint32());
                        }
                    }
                    else {
                        message.failpingAccountIdSessions.push(reader.uint32());
                    }
                    break;
                case 9:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.penaltyAccountIdSessions.push(reader.uint32());
                        }
                    }
                    else {
                        message.penaltyAccountIdSessions.push(reader.uint32());
                    }
                    break;
                case 10:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.failreadyAccountIdSessions.push(reader.uint32());
                        }
                    }
                    else {
                        message.failreadyAccountIdSessions.push(reader.uint32());
                    }
                    break;
                case 11:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.vacbannedAccountIdSessions.push(reader.uint32());
                        }
                    }
                    else {
                        message.vacbannedAccountIdSessions.push(reader.uint32());
                    }
                    break;
                case 12:
                    message.serverIpaddressMask = exports.IpAddressMask.decode(reader, reader.uint32());
                    break;
                case 13:
                    message.notes.push(exports.CMsgGCCStrike15V2MatchmakingGC2ClientUpdate_Note.decode(reader, reader.uint32()));
                    break;
                case 14:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.penaltyAccountIdSessionsGreen.push(reader.uint32());
                        }
                    }
                    else {
                        message.penaltyAccountIdSessionsGreen.push(reader.uint32());
                    }
                    break;
                case 15:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.insufficientlevelSessions.push(reader.uint32());
                        }
                    }
                    else {
                        message.insufficientlevelSessions.push(reader.uint32());
                    }
                    break;
                case 16:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.vsncheckAccountIdSessions.push(reader.uint32());
                        }
                    }
                    else {
                        message.vsncheckAccountIdSessions.push(reader.uint32());
                    }
                    break;
                case 17:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.launcherMismatchSessions.push(reader.uint32());
                        }
                    }
                    else {
                        message.launcherMismatchSessions.push(reader.uint32());
                    }
                    break;
                case 18:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.insecureAccountIdSessions.push(reader.uint32());
                        }
                    }
                    else {
                        message.insecureAccountIdSessions.push(reader.uint32());
                    }
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientUpdate();
        message.matchmaking = (_a = object.matchmaking) !== null && _a !== void 0 ? _a : 0;
        message.waitingAccountIdSessions =
            ((_b = object.waitingAccountIdSessions) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];
        message.error = (_c = object.error) !== null && _c !== void 0 ? _c : "";
        message.ongoingmatchAccountIdSessions =
            ((_d = object.ongoingmatchAccountIdSessions) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];
        message.globalStats =
            object.globalStats !== undefined && object.globalStats !== null
                ? exports.GlobalStatistics.fromPartial(object.globalStats)
                : undefined;
        message.failpingAccountIdSessions =
            ((_e = object.failpingAccountIdSessions) === null || _e === void 0 ? void 0 : _e.map(e => e)) || [];
        message.penaltyAccountIdSessions =
            ((_f = object.penaltyAccountIdSessions) === null || _f === void 0 ? void 0 : _f.map(e => e)) || [];
        message.failreadyAccountIdSessions =
            ((_g = object.failreadyAccountIdSessions) === null || _g === void 0 ? void 0 : _g.map(e => e)) || [];
        message.vacbannedAccountIdSessions =
            ((_h = object.vacbannedAccountIdSessions) === null || _h === void 0 ? void 0 : _h.map(e => e)) || [];
        message.serverIpaddressMask =
            object.serverIpaddressMask !== undefined &&
                object.serverIpaddressMask !== null
                ? exports.IpAddressMask.fromPartial(object.serverIpaddressMask)
                : undefined;
        message.notes =
            ((_j = object.notes) === null || _j === void 0 ? void 0 : _j.map(e => exports.CMsgGCCStrike15V2MatchmakingGC2ClientUpdate_Note.fromPartial(e))) || [];
        message.penaltyAccountIdSessionsGreen =
            ((_k = object.penaltyAccountIdSessionsGreen) === null || _k === void 0 ? void 0 : _k.map(e => e)) || [];
        message.insufficientlevelSessions =
            ((_l = object.insufficientlevelSessions) === null || _l === void 0 ? void 0 : _l.map(e => e)) || [];
        message.vsncheckAccountIdSessions =
            ((_m = object.vsncheckAccountIdSessions) === null || _m === void 0 ? void 0 : _m.map(e => e)) || [];
        message.launcherMismatchSessions =
            ((_o = object.launcherMismatchSessions) === null || _o === void 0 ? void 0 : _o.map(e => e)) || [];
        message.insecureAccountIdSessions =
            ((_p = object.insecureAccountIdSessions) === null || _p === void 0 ? void 0 : _p.map(e => e)) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchmakingGC2ClientUpdate_Note() {
    return { type: 0, regionId: 0, regionR: 0, distance: 0 };
}
exports.CMsgGCCStrike15V2MatchmakingGC2ClientUpdate_Note = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.type !== 0) {
            writer.uint32(8).int32(message.type);
        }
        if (message.regionId !== 0) {
            writer.uint32(16).int32(message.regionId);
        }
        if (message.regionR !== 0) {
            writer.uint32(29).float(message.regionR);
        }
        if (message.distance !== 0) {
            writer.uint32(37).float(message.distance);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientUpdate_Note();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.type = reader.int32();
                    break;
                case 2:
                    message.regionId = reader.int32();
                    break;
                case 3:
                    message.regionR = reader.float();
                    break;
                case 4:
                    message.distance = reader.float();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientUpdate_Note();
        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;
        message.regionId = (_b = object.regionId) !== null && _b !== void 0 ? _b : 0;
        message.regionR = (_c = object.regionR) !== null && _c !== void 0 ? _c : 0;
        message.distance = (_d = object.distance) !== null && _d !== void 0 ? _d : 0;
        return message;
    }
};
function createBaseCDataGCCStrike15V2TournamentMatchDraft() {
    return {
        eventId: 0,
        eventStageId: 0,
        teamId0: 0,
        teamId1: 0,
        mapsCount: 0,
        mapsCurrent: 0,
        teamIdStart: 0,
        teamIdVeto1: 0,
        teamIdPickn: 0,
        drafts: []
    };
}
exports.CDataGCCStrike15V2TournamentMatchDraft = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.eventId !== 0) {
            writer.uint32(8).int32(message.eventId);
        }
        if (message.eventStageId !== 0) {
            writer.uint32(16).int32(message.eventStageId);
        }
        if (message.teamId0 !== 0) {
            writer.uint32(24).int32(message.teamId0);
        }
        if (message.teamId1 !== 0) {
            writer.uint32(32).int32(message.teamId1);
        }
        if (message.mapsCount !== 0) {
            writer.uint32(40).int32(message.mapsCount);
        }
        if (message.mapsCurrent !== 0) {
            writer.uint32(48).int32(message.mapsCurrent);
        }
        if (message.teamIdStart !== 0) {
            writer.uint32(56).int32(message.teamIdStart);
        }
        if (message.teamIdVeto1 !== 0) {
            writer.uint32(64).int32(message.teamIdVeto1);
        }
        if (message.teamIdPickn !== 0) {
            writer.uint32(72).int32(message.teamIdPickn);
        }
        for (const v of message.drafts) {
            exports.CDataGCCStrike15V2TournamentMatchDraft_Entry.encode(v, writer.uint32(82).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCDataGCCStrike15V2TournamentMatchDraft();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.eventId = reader.int32();
                    break;
                case 2:
                    message.eventStageId = reader.int32();
                    break;
                case 3:
                    message.teamId0 = reader.int32();
                    break;
                case 4:
                    message.teamId1 = reader.int32();
                    break;
                case 5:
                    message.mapsCount = reader.int32();
                    break;
                case 6:
                    message.mapsCurrent = reader.int32();
                    break;
                case 7:
                    message.teamIdStart = reader.int32();
                    break;
                case 8:
                    message.teamIdVeto1 = reader.int32();
                    break;
                case 9:
                    message.teamIdPickn = reader.int32();
                    break;
                case 10:
                    message.drafts.push(exports.CDataGCCStrike15V2TournamentMatchDraft_Entry.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
        const message = createBaseCDataGCCStrike15V2TournamentMatchDraft();
        message.eventId = (_a = object.eventId) !== null && _a !== void 0 ? _a : 0;
        message.eventStageId = (_b = object.eventStageId) !== null && _b !== void 0 ? _b : 0;
        message.teamId0 = (_c = object.teamId0) !== null && _c !== void 0 ? _c : 0;
        message.teamId1 = (_d = object.teamId1) !== null && _d !== void 0 ? _d : 0;
        message.mapsCount = (_e = object.mapsCount) !== null && _e !== void 0 ? _e : 0;
        message.mapsCurrent = (_f = object.mapsCurrent) !== null && _f !== void 0 ? _f : 0;
        message.teamIdStart = (_g = object.teamIdStart) !== null && _g !== void 0 ? _g : 0;
        message.teamIdVeto1 = (_h = object.teamIdVeto1) !== null && _h !== void 0 ? _h : 0;
        message.teamIdPickn = (_j = object.teamIdPickn) !== null && _j !== void 0 ? _j : 0;
        message.drafts =
            ((_k = object.drafts) === null || _k === void 0 ? void 0 : _k.map(e => exports.CDataGCCStrike15V2TournamentMatchDraft_Entry.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCDataGCCStrike15V2TournamentMatchDraft_Entry() {
    return { mapid: 0, teamIdCt: 0 };
}
exports.CDataGCCStrike15V2TournamentMatchDraft_Entry = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.mapid !== 0) {
            writer.uint32(8).int32(message.mapid);
        }
        if (message.teamIdCt !== 0) {
            writer.uint32(16).int32(message.teamIdCt);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCDataGCCStrike15V2TournamentMatchDraft_Entry();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.mapid = reader.int32();
                    break;
                case 2:
                    message.teamIdCt = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCDataGCCStrike15V2TournamentMatchDraft_Entry();
        message.mapid = (_a = object.mapid) !== null && _a !== void 0 ? _a : 0;
        message.teamIdCt = (_b = object.teamIdCt) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCPreMatchInfoData() {
    return { predictionsPct: 0, draft: undefined, stats: [], wins: [] };
}
exports.CPreMatchInfoData = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.predictionsPct !== 0) {
            writer.uint32(8).int32(message.predictionsPct);
        }
        if (message.draft !== undefined) {
            exports.CDataGCCStrike15V2TournamentMatchDraft.encode(message.draft, writer.uint32(34).fork()).ldelim();
        }
        for (const v of message.stats) {
            exports.CPreMatchInfoData_TeamStats.encode(v, writer.uint32(42).fork()).ldelim();
        }
        writer.uint32(50).fork();
        for (const v of message.wins) {
            writer.int32(v);
        }
        writer.ldelim();
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCPreMatchInfoData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.predictionsPct = reader.int32();
                    break;
                case 4:
                    message.draft = exports.CDataGCCStrike15V2TournamentMatchDraft.decode(reader, reader.uint32());
                    break;
                case 5:
                    message.stats.push(exports.CPreMatchInfoData_TeamStats.decode(reader, reader.uint32()));
                    break;
                case 6:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.wins.push(reader.int32());
                        }
                    }
                    else {
                        message.wins.push(reader.int32());
                    }
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCPreMatchInfoData();
        message.predictionsPct = (_a = object.predictionsPct) !== null && _a !== void 0 ? _a : 0;
        message.draft =
            object.draft !== undefined && object.draft !== null
                ? exports.CDataGCCStrike15V2TournamentMatchDraft.fromPartial(object.draft)
                : undefined;
        message.stats =
            ((_b = object.stats) === null || _b === void 0 ? void 0 : _b.map(e => exports.CPreMatchInfoData_TeamStats.fromPartial(e))) || [];
        message.wins = ((_c = object.wins) === null || _c === void 0 ? void 0 : _c.map(e => e)) || [];
        return message;
    }
};
function createBaseCPreMatchInfoData_TeamStats() {
    return { matchInfoIdxtxt: 0, matchInfoTxt: "", matchInfoTeams: [] };
}
exports.CPreMatchInfoData_TeamStats = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.matchInfoIdxtxt !== 0) {
            writer.uint32(8).int32(message.matchInfoIdxtxt);
        }
        if (message.matchInfoTxt !== "") {
            writer.uint32(18).string(message.matchInfoTxt);
        }
        for (const v of message.matchInfoTeams) {
            writer.uint32(26).string(v);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCPreMatchInfoData_TeamStats();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.matchInfoIdxtxt = reader.int32();
                    break;
                case 2:
                    message.matchInfoTxt = reader.string();
                    break;
                case 3:
                    message.matchInfoTeams.push(reader.string());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCPreMatchInfoData_TeamStats();
        message.matchInfoIdxtxt = (_a = object.matchInfoIdxtxt) !== null && _a !== void 0 ? _a : 0;
        message.matchInfoTxt = (_b = object.matchInfoTxt) !== null && _b !== void 0 ? _b : "";
        message.matchInfoTeams = ((_c = object.matchInfoTeams) === null || _c === void 0 ? void 0 : _c.map(e => e)) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchmakingGC2ServerReserve() {
    return {
        accountIds: [],
        gameType: 0,
        matchId: Long.UZERO,
        serverVersion: 0,
        flags: 0,
        rankings: [],
        encryptionKey: Long.UZERO,
        encryptionKeyPub: Long.UZERO,
        partyIds: [],
        whitelist: [],
        tvMasterSteamid: Long.UZERO,
        tournamentEvent: undefined,
        tournamentTeams: [],
        tournamentCastersAccountIds: [],
        tvRelaySteamid: Long.UZERO,
        preMatchData: undefined,
        rtime32EventStart: 0,
        tvControl: 0
    };
}
exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve = {
    encode(message, writer = minimal_1.Writer.create()) {
        writer.uint32(10).fork();
        for (const v of message.accountIds) {
            writer.uint32(v);
        }
        writer.ldelim();
        if (message.gameType !== 0) {
            writer.uint32(16).uint32(message.gameType);
        }
        if (!message.matchId.isZero()) {
            writer.uint32(24).uint64(message.matchId);
        }
        if (message.serverVersion !== 0) {
            writer.uint32(32).uint32(message.serverVersion);
        }
        if (message.flags !== 0) {
            writer.uint32(144).uint32(message.flags);
        }
        for (const v of message.rankings) {
            exports.PlayerRankingInfo.encode(v, writer.uint32(42).fork()).ldelim();
        }
        if (!message.encryptionKey.isZero()) {
            writer.uint32(48).uint64(message.encryptionKey);
        }
        if (!message.encryptionKeyPub.isZero()) {
            writer.uint32(56).uint64(message.encryptionKeyPub);
        }
        writer.uint32(66).fork();
        for (const v of message.partyIds) {
            writer.uint32(v);
        }
        writer.ldelim();
        for (const v of message.whitelist) {
            exports.IpAddressMask.encode(v, writer.uint32(74).fork()).ldelim();
        }
        if (!message.tvMasterSteamid.isZero()) {
            writer.uint32(80).uint64(message.tvMasterSteamid);
        }
        if (message.tournamentEvent !== undefined) {
            exports.TournamentEvent.encode(message.tournamentEvent, writer.uint32(90).fork()).ldelim();
        }
        for (const v of message.tournamentTeams) {
            exports.TournamentTeam.encode(v, writer.uint32(98).fork()).ldelim();
        }
        writer.uint32(106).fork();
        for (const v of message.tournamentCastersAccountIds) {
            writer.uint32(v);
        }
        writer.ldelim();
        if (!message.tvRelaySteamid.isZero()) {
            writer.uint32(112).uint64(message.tvRelaySteamid);
        }
        if (message.preMatchData !== undefined) {
            exports.CPreMatchInfoData.encode(message.preMatchData, writer.uint32(122).fork()).ldelim();
        }
        if (message.rtime32EventStart !== 0) {
            writer.uint32(128).uint32(message.rtime32EventStart);
        }
        if (message.tvControl !== 0) {
            writer.uint32(136).uint32(message.tvControl);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ServerReserve();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.accountIds.push(reader.uint32());
                        }
                    }
                    else {
                        message.accountIds.push(reader.uint32());
                    }
                    break;
                case 2:
                    message.gameType = reader.uint32();
                    break;
                case 3:
                    message.matchId = reader.uint64();
                    break;
                case 4:
                    message.serverVersion = reader.uint32();
                    break;
                case 18:
                    message.flags = reader.uint32();
                    break;
                case 5:
                    message.rankings.push(exports.PlayerRankingInfo.decode(reader, reader.uint32()));
                    break;
                case 6:
                    message.encryptionKey = reader.uint64();
                    break;
                case 7:
                    message.encryptionKeyPub = reader.uint64();
                    break;
                case 8:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.partyIds.push(reader.uint32());
                        }
                    }
                    else {
                        message.partyIds.push(reader.uint32());
                    }
                    break;
                case 9:
                    message.whitelist.push(exports.IpAddressMask.decode(reader, reader.uint32()));
                    break;
                case 10:
                    message.tvMasterSteamid = reader.uint64();
                    break;
                case 11:
                    message.tournamentEvent = exports.TournamentEvent.decode(reader, reader.uint32());
                    break;
                case 12:
                    message.tournamentTeams.push(exports.TournamentTeam.decode(reader, reader.uint32()));
                    break;
                case 13:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.tournamentCastersAccountIds.push(reader.uint32());
                        }
                    }
                    else {
                        message.tournamentCastersAccountIds.push(reader.uint32());
                    }
                    break;
                case 14:
                    message.tvRelaySteamid = reader.uint64();
                    break;
                case 15:
                    message.preMatchData = exports.CPreMatchInfoData.decode(reader, reader.uint32());
                    break;
                case 16:
                    message.rtime32EventStart = reader.uint32();
                    break;
                case 17:
                    message.tvControl = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ServerReserve();
        message.accountIds = ((_a = object.accountIds) === null || _a === void 0 ? void 0 : _a.map(e => e)) || [];
        message.gameType = (_b = object.gameType) !== null && _b !== void 0 ? _b : 0;
        message.matchId =
            object.matchId !== undefined && object.matchId !== null
                ? Long.fromValue(object.matchId)
                : Long.UZERO;
        message.serverVersion = (_c = object.serverVersion) !== null && _c !== void 0 ? _c : 0;
        message.flags = (_d = object.flags) !== null && _d !== void 0 ? _d : 0;
        message.rankings =
            ((_e = object.rankings) === null || _e === void 0 ? void 0 : _e.map(e => exports.PlayerRankingInfo.fromPartial(e))) || [];
        message.encryptionKey =
            object.encryptionKey !== undefined && object.encryptionKey !== null
                ? Long.fromValue(object.encryptionKey)
                : Long.UZERO;
        message.encryptionKeyPub =
            object.encryptionKeyPub !== undefined && object.encryptionKeyPub !== null
                ? Long.fromValue(object.encryptionKeyPub)
                : Long.UZERO;
        message.partyIds = ((_f = object.partyIds) === null || _f === void 0 ? void 0 : _f.map(e => e)) || [];
        message.whitelist =
            ((_g = object.whitelist) === null || _g === void 0 ? void 0 : _g.map(e => exports.IpAddressMask.fromPartial(e))) || [];
        message.tvMasterSteamid =
            object.tvMasterSteamid !== undefined && object.tvMasterSteamid !== null
                ? Long.fromValue(object.tvMasterSteamid)
                : Long.UZERO;
        message.tournamentEvent =
            object.tournamentEvent !== undefined && object.tournamentEvent !== null
                ? exports.TournamentEvent.fromPartial(object.tournamentEvent)
                : undefined;
        message.tournamentTeams =
            ((_h = object.tournamentTeams) === null || _h === void 0 ? void 0 : _h.map(e => exports.TournamentTeam.fromPartial(e))) || [];
        message.tournamentCastersAccountIds =
            ((_j = object.tournamentCastersAccountIds) === null || _j === void 0 ? void 0 : _j.map(e => e)) || [];
        message.tvRelaySteamid =
            object.tvRelaySteamid !== undefined && object.tvRelaySteamid !== null
                ? Long.fromValue(object.tvRelaySteamid)
                : Long.UZERO;
        message.preMatchData =
            object.preMatchData !== undefined && object.preMatchData !== null
                ? exports.CPreMatchInfoData.fromPartial(object.preMatchData)
                : undefined;
        message.rtime32EventStart = (_k = object.rtime32EventStart) !== null && _k !== void 0 ? _k : 0;
        message.tvControl = (_l = object.tvControl) !== null && _l !== void 0 ? _l : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchmakingServerReservationResponse() {
    return {
        reservationid: Long.UZERO,
        reservation: undefined,
        map: "",
        gcReservationSent: Long.UZERO,
        serverVersion: 0,
        tvInfo: undefined,
        rewardPlayerAccounts: [],
        idlePlayerAccounts: [],
        rewardItemAttrDefIdx: 0,
        rewardItemAttrValue: 0,
        rewardItemAttrRewardIdx: 0,
        rewardDropList: 0,
        tournamentTag: "",
        legacySteamdatagramPort: 0,
        steamdatagramRouting: 0,
        testToken: 0,
        flags: 0
    };
}
exports.CMsgGCCStrike15V2MatchmakingServerReservationResponse = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.reservationid.isZero()) {
            writer.uint32(8).uint64(message.reservationid);
        }
        if (message.reservation !== undefined) {
            exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.encode(message.reservation, writer.uint32(18).fork()).ldelim();
        }
        if (message.map !== "") {
            writer.uint32(26).string(message.map);
        }
        if (!message.gcReservationSent.isZero()) {
            writer.uint32(32).uint64(message.gcReservationSent);
        }
        if (message.serverVersion !== 0) {
            writer.uint32(40).uint32(message.serverVersion);
        }
        if (message.tvInfo !== undefined) {
            exports.ServerHltvInfo.encode(message.tvInfo, writer.uint32(50).fork()).ldelim();
        }
        writer.uint32(58).fork();
        for (const v of message.rewardPlayerAccounts) {
            writer.uint32(v);
        }
        writer.ldelim();
        writer.uint32(66).fork();
        for (const v of message.idlePlayerAccounts) {
            writer.uint32(v);
        }
        writer.ldelim();
        if (message.rewardItemAttrDefIdx !== 0) {
            writer.uint32(72).uint32(message.rewardItemAttrDefIdx);
        }
        if (message.rewardItemAttrValue !== 0) {
            writer.uint32(80).uint32(message.rewardItemAttrValue);
        }
        if (message.rewardItemAttrRewardIdx !== 0) {
            writer.uint32(88).uint32(message.rewardItemAttrRewardIdx);
        }
        if (message.rewardDropList !== 0) {
            writer.uint32(96).uint32(message.rewardDropList);
        }
        if (message.tournamentTag !== "") {
            writer.uint32(106).string(message.tournamentTag);
        }
        if (message.legacySteamdatagramPort !== 0) {
            writer.uint32(112).uint32(message.legacySteamdatagramPort);
        }
        if (message.steamdatagramRouting !== 0) {
            writer.uint32(136).uint32(message.steamdatagramRouting);
        }
        if (message.testToken !== 0) {
            writer.uint32(125).fixed32(message.testToken);
        }
        if (message.flags !== 0) {
            writer.uint32(128).uint32(message.flags);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchmakingServerReservationResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.reservationid = reader.uint64();
                    break;
                case 2:
                    message.reservation =
                        exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.map = reader.string();
                    break;
                case 4:
                    message.gcReservationSent = reader.uint64();
                    break;
                case 5:
                    message.serverVersion = reader.uint32();
                    break;
                case 6:
                    message.tvInfo = exports.ServerHltvInfo.decode(reader, reader.uint32());
                    break;
                case 7:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.rewardPlayerAccounts.push(reader.uint32());
                        }
                    }
                    else {
                        message.rewardPlayerAccounts.push(reader.uint32());
                    }
                    break;
                case 8:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.idlePlayerAccounts.push(reader.uint32());
                        }
                    }
                    else {
                        message.idlePlayerAccounts.push(reader.uint32());
                    }
                    break;
                case 9:
                    message.rewardItemAttrDefIdx = reader.uint32();
                    break;
                case 10:
                    message.rewardItemAttrValue = reader.uint32();
                    break;
                case 11:
                    message.rewardItemAttrRewardIdx = reader.uint32();
                    break;
                case 12:
                    message.rewardDropList = reader.uint32();
                    break;
                case 13:
                    message.tournamentTag = reader.string();
                    break;
                case 14:
                    message.legacySteamdatagramPort = reader.uint32();
                    break;
                case 17:
                    message.steamdatagramRouting = reader.uint32();
                    break;
                case 15:
                    message.testToken = reader.fixed32();
                    break;
                case 16:
                    message.flags = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
        const message = createBaseCMsgGCCStrike15V2MatchmakingServerReservationResponse();
        message.reservationid =
            object.reservationid !== undefined && object.reservationid !== null
                ? Long.fromValue(object.reservationid)
                : Long.UZERO;
        message.reservation =
            object.reservation !== undefined && object.reservation !== null
                ? exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.fromPartial(object.reservation)
                : undefined;
        message.map = (_a = object.map) !== null && _a !== void 0 ? _a : "";
        message.gcReservationSent =
            object.gcReservationSent !== undefined &&
                object.gcReservationSent !== null
                ? Long.fromValue(object.gcReservationSent)
                : Long.UZERO;
        message.serverVersion = (_b = object.serverVersion) !== null && _b !== void 0 ? _b : 0;
        message.tvInfo =
            object.tvInfo !== undefined && object.tvInfo !== null
                ? exports.ServerHltvInfo.fromPartial(object.tvInfo)
                : undefined;
        message.rewardPlayerAccounts =
            ((_c = object.rewardPlayerAccounts) === null || _c === void 0 ? void 0 : _c.map(e => e)) || [];
        message.idlePlayerAccounts = ((_d = object.idlePlayerAccounts) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];
        message.rewardItemAttrDefIdx = (_e = object.rewardItemAttrDefIdx) !== null && _e !== void 0 ? _e : 0;
        message.rewardItemAttrValue = (_f = object.rewardItemAttrValue) !== null && _f !== void 0 ? _f : 0;
        message.rewardItemAttrRewardIdx = (_g = object.rewardItemAttrRewardIdx) !== null && _g !== void 0 ? _g : 0;
        message.rewardDropList = (_h = object.rewardDropList) !== null && _h !== void 0 ? _h : 0;
        message.tournamentTag = (_j = object.tournamentTag) !== null && _j !== void 0 ? _j : "";
        message.legacySteamdatagramPort = (_k = object.legacySteamdatagramPort) !== null && _k !== void 0 ? _k : 0;
        message.steamdatagramRouting = (_l = object.steamdatagramRouting) !== null && _l !== void 0 ? _l : 0;
        message.testToken = (_m = object.testToken) !== null && _m !== void 0 ? _m : 0;
        message.flags = (_o = object.flags) !== null && _o !== void 0 ? _o : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchmakingGC2ClientReserve() {
    return {
        serverid: Long.UZERO,
        directUdpIp: 0,
        directUdpPort: 0,
        reservationid: Long.UZERO,
        reservation: undefined,
        map: "",
        serverAddress: ""
    };
}
exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.serverid.isZero()) {
            writer.uint32(8).uint64(message.serverid);
        }
        if (message.directUdpIp !== 0) {
            writer.uint32(16).uint32(message.directUdpIp);
        }
        if (message.directUdpPort !== 0) {
            writer.uint32(24).uint32(message.directUdpPort);
        }
        if (!message.reservationid.isZero()) {
            writer.uint32(32).uint64(message.reservationid);
        }
        if (message.reservation !== undefined) {
            exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.encode(message.reservation, writer.uint32(42).fork()).ldelim();
        }
        if (message.map !== "") {
            writer.uint32(50).string(message.map);
        }
        if (message.serverAddress !== "") {
            writer.uint32(58).string(message.serverAddress);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientReserve();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.serverid = reader.uint64();
                    break;
                case 2:
                    message.directUdpIp = reader.uint32();
                    break;
                case 3:
                    message.directUdpPort = reader.uint32();
                    break;
                case 4:
                    message.reservationid = reader.uint64();
                    break;
                case 5:
                    message.reservation =
                        exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.decode(reader, reader.uint32());
                    break;
                case 6:
                    message.map = reader.string();
                    break;
                case 7:
                    message.serverAddress = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientReserve();
        message.serverid =
            object.serverid !== undefined && object.serverid !== null
                ? Long.fromValue(object.serverid)
                : Long.UZERO;
        message.directUdpIp = (_a = object.directUdpIp) !== null && _a !== void 0 ? _a : 0;
        message.directUdpPort = (_b = object.directUdpPort) !== null && _b !== void 0 ? _b : 0;
        message.reservationid =
            object.reservationid !== undefined && object.reservationid !== null
                ? Long.fromValue(object.reservationid)
                : Long.UZERO;
        message.reservation =
            object.reservation !== undefined && object.reservation !== null
                ? exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.fromPartial(object.reservation)
                : undefined;
        message.map = (_c = object.map) !== null && _c !== void 0 ? _c : "";
        message.serverAddress = (_d = object.serverAddress) !== null && _d !== void 0 ? _d : "";
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchmakingServerRoundStats() {
    return {
        reservationid: Long.UZERO,
        reservation: undefined,
        map: "",
        round: 0,
        kills: [],
        assists: [],
        deaths: [],
        scores: [],
        pings: [],
        roundResult: 0,
        matchResult: 0,
        teamScores: [],
        confirm: undefined,
        reservationStage: 0,
        matchDuration: 0,
        enemyKills: [],
        enemyHeadshots: [],
        enemy3ks: [],
        enemy4ks: [],
        enemy5ks: [],
        mvps: [],
        spectatorsCount: 0,
        spectatorsCountTv: 0,
        spectatorsCountLnk: 0,
        enemyKillsAgg: [],
        dropInfo: undefined,
        bSwitchedTeams: false,
        enemy2ks: [],
        playerSpawned: [],
        teamSpawnCount: [],
        maxRounds: 0
    };
}
exports.CMsgGCCStrike15V2MatchmakingServerRoundStats = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.reservationid.isZero()) {
            writer.uint32(8).uint64(message.reservationid);
        }
        if (message.reservation !== undefined) {
            exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.encode(message.reservation, writer.uint32(18).fork()).ldelim();
        }
        if (message.map !== "") {
            writer.uint32(26).string(message.map);
        }
        if (message.round !== 0) {
            writer.uint32(32).int32(message.round);
        }
        writer.uint32(42).fork();
        for (const v of message.kills) {
            writer.int32(v);
        }
        writer.ldelim();
        writer.uint32(50).fork();
        for (const v of message.assists) {
            writer.int32(v);
        }
        writer.ldelim();
        writer.uint32(58).fork();
        for (const v of message.deaths) {
            writer.int32(v);
        }
        writer.ldelim();
        writer.uint32(66).fork();
        for (const v of message.scores) {
            writer.int32(v);
        }
        writer.ldelim();
        writer.uint32(74).fork();
        for (const v of message.pings) {
            writer.int32(v);
        }
        writer.ldelim();
        if (message.roundResult !== 0) {
            writer.uint32(80).int32(message.roundResult);
        }
        if (message.matchResult !== 0) {
            writer.uint32(88).int32(message.matchResult);
        }
        writer.uint32(98).fork();
        for (const v of message.teamScores) {
            writer.int32(v);
        }
        writer.ldelim();
        if (message.confirm !== undefined) {
            exports.CMsgGCCStrike15V2MatchmakingGC2ServerConfirm.encode(message.confirm, writer.uint32(106).fork()).ldelim();
        }
        if (message.reservationStage !== 0) {
            writer.uint32(112).int32(message.reservationStage);
        }
        if (message.matchDuration !== 0) {
            writer.uint32(120).int32(message.matchDuration);
        }
        writer.uint32(130).fork();
        for (const v of message.enemyKills) {
            writer.int32(v);
        }
        writer.ldelim();
        writer.uint32(138).fork();
        for (const v of message.enemyHeadshots) {
            writer.int32(v);
        }
        writer.ldelim();
        writer.uint32(146).fork();
        for (const v of message.enemy3ks) {
            writer.int32(v);
        }
        writer.ldelim();
        writer.uint32(154).fork();
        for (const v of message.enemy4ks) {
            writer.int32(v);
        }
        writer.ldelim();
        writer.uint32(162).fork();
        for (const v of message.enemy5ks) {
            writer.int32(v);
        }
        writer.ldelim();
        writer.uint32(170).fork();
        for (const v of message.mvps) {
            writer.int32(v);
        }
        writer.ldelim();
        if (message.spectatorsCount !== 0) {
            writer.uint32(176).uint32(message.spectatorsCount);
        }
        if (message.spectatorsCountTv !== 0) {
            writer.uint32(184).uint32(message.spectatorsCountTv);
        }
        if (message.spectatorsCountLnk !== 0) {
            writer.uint32(192).uint32(message.spectatorsCountLnk);
        }
        writer.uint32(202).fork();
        for (const v of message.enemyKillsAgg) {
            writer.int32(v);
        }
        writer.ldelim();
        if (message.dropInfo !== undefined) {
            exports.CMsgGCCStrike15V2MatchmakingServerRoundStats_DropInfo.encode(message.dropInfo, writer.uint32(210).fork()).ldelim();
        }
        if (message.bSwitchedTeams === true) {
            writer.uint32(216).bool(message.bSwitchedTeams);
        }
        writer.uint32(226).fork();
        for (const v of message.enemy2ks) {
            writer.int32(v);
        }
        writer.ldelim();
        writer.uint32(234).fork();
        for (const v of message.playerSpawned) {
            writer.int32(v);
        }
        writer.ldelim();
        writer.uint32(242).fork();
        for (const v of message.teamSpawnCount) {
            writer.int32(v);
        }
        writer.ldelim();
        if (message.maxRounds !== 0) {
            writer.uint32(248).uint32(message.maxRounds);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchmakingServerRoundStats();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.reservationid = reader.uint64();
                    break;
                case 2:
                    message.reservation =
                        exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.map = reader.string();
                    break;
                case 4:
                    message.round = reader.int32();
                    break;
                case 5:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.kills.push(reader.int32());
                        }
                    }
                    else {
                        message.kills.push(reader.int32());
                    }
                    break;
                case 6:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.assists.push(reader.int32());
                        }
                    }
                    else {
                        message.assists.push(reader.int32());
                    }
                    break;
                case 7:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.deaths.push(reader.int32());
                        }
                    }
                    else {
                        message.deaths.push(reader.int32());
                    }
                    break;
                case 8:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.scores.push(reader.int32());
                        }
                    }
                    else {
                        message.scores.push(reader.int32());
                    }
                    break;
                case 9:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.pings.push(reader.int32());
                        }
                    }
                    else {
                        message.pings.push(reader.int32());
                    }
                    break;
                case 10:
                    message.roundResult = reader.int32();
                    break;
                case 11:
                    message.matchResult = reader.int32();
                    break;
                case 12:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.teamScores.push(reader.int32());
                        }
                    }
                    else {
                        message.teamScores.push(reader.int32());
                    }
                    break;
                case 13:
                    message.confirm = exports.CMsgGCCStrike15V2MatchmakingGC2ServerConfirm.decode(reader, reader.uint32());
                    break;
                case 14:
                    message.reservationStage = reader.int32();
                    break;
                case 15:
                    message.matchDuration = reader.int32();
                    break;
                case 16:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.enemyKills.push(reader.int32());
                        }
                    }
                    else {
                        message.enemyKills.push(reader.int32());
                    }
                    break;
                case 17:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.enemyHeadshots.push(reader.int32());
                        }
                    }
                    else {
                        message.enemyHeadshots.push(reader.int32());
                    }
                    break;
                case 18:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.enemy3ks.push(reader.int32());
                        }
                    }
                    else {
                        message.enemy3ks.push(reader.int32());
                    }
                    break;
                case 19:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.enemy4ks.push(reader.int32());
                        }
                    }
                    else {
                        message.enemy4ks.push(reader.int32());
                    }
                    break;
                case 20:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.enemy5ks.push(reader.int32());
                        }
                    }
                    else {
                        message.enemy5ks.push(reader.int32());
                    }
                    break;
                case 21:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.mvps.push(reader.int32());
                        }
                    }
                    else {
                        message.mvps.push(reader.int32());
                    }
                    break;
                case 22:
                    message.spectatorsCount = reader.uint32();
                    break;
                case 23:
                    message.spectatorsCountTv = reader.uint32();
                    break;
                case 24:
                    message.spectatorsCountLnk = reader.uint32();
                    break;
                case 25:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.enemyKillsAgg.push(reader.int32());
                        }
                    }
                    else {
                        message.enemyKillsAgg.push(reader.int32());
                    }
                    break;
                case 26:
                    message.dropInfo =
                        exports.CMsgGCCStrike15V2MatchmakingServerRoundStats_DropInfo.decode(reader, reader.uint32());
                    break;
                case 27:
                    message.bSwitchedTeams = reader.bool();
                    break;
                case 28:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.enemy2ks.push(reader.int32());
                        }
                    }
                    else {
                        message.enemy2ks.push(reader.int32());
                    }
                    break;
                case 29:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.playerSpawned.push(reader.int32());
                        }
                    }
                    else {
                        message.playerSpawned.push(reader.int32());
                    }
                    break;
                case 30:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.teamSpawnCount.push(reader.int32());
                        }
                    }
                    else {
                        message.teamSpawnCount.push(reader.int32());
                    }
                    break;
                case 31:
                    message.maxRounds = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2;
        const message = createBaseCMsgGCCStrike15V2MatchmakingServerRoundStats();
        message.reservationid =
            object.reservationid !== undefined && object.reservationid !== null
                ? Long.fromValue(object.reservationid)
                : Long.UZERO;
        message.reservation =
            object.reservation !== undefined && object.reservation !== null
                ? exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.fromPartial(object.reservation)
                : undefined;
        message.map = (_a = object.map) !== null && _a !== void 0 ? _a : "";
        message.round = (_b = object.round) !== null && _b !== void 0 ? _b : 0;
        message.kills = ((_c = object.kills) === null || _c === void 0 ? void 0 : _c.map(e => e)) || [];
        message.assists = ((_d = object.assists) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];
        message.deaths = ((_e = object.deaths) === null || _e === void 0 ? void 0 : _e.map(e => e)) || [];
        message.scores = ((_f = object.scores) === null || _f === void 0 ? void 0 : _f.map(e => e)) || [];
        message.pings = ((_g = object.pings) === null || _g === void 0 ? void 0 : _g.map(e => e)) || [];
        message.roundResult = (_h = object.roundResult) !== null && _h !== void 0 ? _h : 0;
        message.matchResult = (_j = object.matchResult) !== null && _j !== void 0 ? _j : 0;
        message.teamScores = ((_k = object.teamScores) === null || _k === void 0 ? void 0 : _k.map(e => e)) || [];
        message.confirm =
            object.confirm !== undefined && object.confirm !== null
                ? exports.CMsgGCCStrike15V2MatchmakingGC2ServerConfirm.fromPartial(object.confirm)
                : undefined;
        message.reservationStage = (_l = object.reservationStage) !== null && _l !== void 0 ? _l : 0;
        message.matchDuration = (_m = object.matchDuration) !== null && _m !== void 0 ? _m : 0;
        message.enemyKills = ((_o = object.enemyKills) === null || _o === void 0 ? void 0 : _o.map(e => e)) || [];
        message.enemyHeadshots = ((_p = object.enemyHeadshots) === null || _p === void 0 ? void 0 : _p.map(e => e)) || [];
        message.enemy3ks = ((_q = object.enemy3ks) === null || _q === void 0 ? void 0 : _q.map(e => e)) || [];
        message.enemy4ks = ((_r = object.enemy4ks) === null || _r === void 0 ? void 0 : _r.map(e => e)) || [];
        message.enemy5ks = ((_s = object.enemy5ks) === null || _s === void 0 ? void 0 : _s.map(e => e)) || [];
        message.mvps = ((_t = object.mvps) === null || _t === void 0 ? void 0 : _t.map(e => e)) || [];
        message.spectatorsCount = (_u = object.spectatorsCount) !== null && _u !== void 0 ? _u : 0;
        message.spectatorsCountTv = (_v = object.spectatorsCountTv) !== null && _v !== void 0 ? _v : 0;
        message.spectatorsCountLnk = (_w = object.spectatorsCountLnk) !== null && _w !== void 0 ? _w : 0;
        message.enemyKillsAgg = ((_x = object.enemyKillsAgg) === null || _x === void 0 ? void 0 : _x.map(e => e)) || [];
        message.dropInfo =
            object.dropInfo !== undefined && object.dropInfo !== null
                ? exports.CMsgGCCStrike15V2MatchmakingServerRoundStats_DropInfo.fromPartial(object.dropInfo)
                : undefined;
        message.bSwitchedTeams = (_y = object.bSwitchedTeams) !== null && _y !== void 0 ? _y : false;
        message.enemy2ks = ((_z = object.enemy2ks) === null || _z === void 0 ? void 0 : _z.map(e => e)) || [];
        message.playerSpawned = ((_0 = object.playerSpawned) === null || _0 === void 0 ? void 0 : _0.map(e => e)) || [];
        message.teamSpawnCount = ((_1 = object.teamSpawnCount) === null || _1 === void 0 ? void 0 : _1.map(e => e)) || [];
        message.maxRounds = (_2 = object.maxRounds) !== null && _2 !== void 0 ? _2 : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchmakingServerRoundStats_DropInfo() {
    return { accountMvp: 0 };
}
exports.CMsgGCCStrike15V2MatchmakingServerRoundStats_DropInfo = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountMvp !== 0) {
            writer.uint32(8).uint32(message.accountMvp);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchmakingServerRoundStats_DropInfo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountMvp = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2MatchmakingServerRoundStats_DropInfo();
        message.accountMvp = (_a = object.accountMvp) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchmakingClient2GCHello() {
    return {};
}
exports.CMsgGCCStrike15V2MatchmakingClient2GCHello = {
    encode(_, writer = minimal_1.Writer.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchmakingClient2GCHello();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseCMsgGCCStrike15V2MatchmakingClient2GCHello();
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchmakingGC2ClientHello() {
    return {
        accountId: 0,
        ongoingmatch: undefined,
        globalStats: undefined,
        penaltySeconds: 0,
        penaltyReason: 0,
        vacBanned: 0,
        ranking: undefined,
        commendation: undefined,
        medals: undefined,
        myCurrentEvent: undefined,
        myCurrentEventTeams: [],
        myCurrentTeam: undefined,
        myCurrentEventStages: [],
        surveyVote: 0,
        activity: undefined,
        playerLevel: 0,
        playerCurXp: 0,
        playerXpBonusFlags: 0,
        rankings: []
    };
}
exports.CMsgGCCStrike15V2MatchmakingGC2ClientHello = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountId !== 0) {
            writer.uint32(8).uint32(message.accountId);
        }
        if (message.ongoingmatch !== undefined) {
            exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.encode(message.ongoingmatch, writer.uint32(18).fork()).ldelim();
        }
        if (message.globalStats !== undefined) {
            exports.GlobalStatistics.encode(message.globalStats, writer.uint32(26).fork()).ldelim();
        }
        if (message.penaltySeconds !== 0) {
            writer.uint32(32).uint32(message.penaltySeconds);
        }
        if (message.penaltyReason !== 0) {
            writer.uint32(40).uint32(message.penaltyReason);
        }
        if (message.vacBanned !== 0) {
            writer.uint32(48).int32(message.vacBanned);
        }
        if (message.ranking !== undefined) {
            exports.PlayerRankingInfo.encode(message.ranking, writer.uint32(58).fork()).ldelim();
        }
        if (message.commendation !== undefined) {
            exports.PlayerCommendationInfo.encode(message.commendation, writer.uint32(66).fork()).ldelim();
        }
        if (message.medals !== undefined) {
            exports.PlayerMedalsInfo.encode(message.medals, writer.uint32(74).fork()).ldelim();
        }
        if (message.myCurrentEvent !== undefined) {
            exports.TournamentEvent.encode(message.myCurrentEvent, writer.uint32(82).fork()).ldelim();
        }
        for (const v of message.myCurrentEventTeams) {
            exports.TournamentTeam.encode(v, writer.uint32(90).fork()).ldelim();
        }
        if (message.myCurrentTeam !== undefined) {
            exports.TournamentTeam.encode(message.myCurrentTeam, writer.uint32(98).fork()).ldelim();
        }
        for (const v of message.myCurrentEventStages) {
            exports.TournamentEvent.encode(v, writer.uint32(106).fork()).ldelim();
        }
        if (message.surveyVote !== 0) {
            writer.uint32(112).uint32(message.surveyVote);
        }
        if (message.activity !== undefined) {
            exports.AccountActivity.encode(message.activity, writer.uint32(122).fork()).ldelim();
        }
        if (message.playerLevel !== 0) {
            writer.uint32(136).int32(message.playerLevel);
        }
        if (message.playerCurXp !== 0) {
            writer.uint32(144).int32(message.playerCurXp);
        }
        if (message.playerXpBonusFlags !== 0) {
            writer.uint32(152).int32(message.playerXpBonusFlags);
        }
        for (const v of message.rankings) {
            exports.PlayerRankingInfo.encode(v, writer.uint32(162).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientHello();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountId = reader.uint32();
                    break;
                case 2:
                    message.ongoingmatch =
                        exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.globalStats = exports.GlobalStatistics.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.penaltySeconds = reader.uint32();
                    break;
                case 5:
                    message.penaltyReason = reader.uint32();
                    break;
                case 6:
                    message.vacBanned = reader.int32();
                    break;
                case 7:
                    message.ranking = exports.PlayerRankingInfo.decode(reader, reader.uint32());
                    break;
                case 8:
                    message.commendation = exports.PlayerCommendationInfo.decode(reader, reader.uint32());
                    break;
                case 9:
                    message.medals = exports.PlayerMedalsInfo.decode(reader, reader.uint32());
                    break;
                case 10:
                    message.myCurrentEvent = exports.TournamentEvent.decode(reader, reader.uint32());
                    break;
                case 11:
                    message.myCurrentEventTeams.push(exports.TournamentTeam.decode(reader, reader.uint32()));
                    break;
                case 12:
                    message.myCurrentTeam = exports.TournamentTeam.decode(reader, reader.uint32());
                    break;
                case 13:
                    message.myCurrentEventStages.push(exports.TournamentEvent.decode(reader, reader.uint32()));
                    break;
                case 14:
                    message.surveyVote = reader.uint32();
                    break;
                case 15:
                    message.activity = exports.AccountActivity.decode(reader, reader.uint32());
                    break;
                case 17:
                    message.playerLevel = reader.int32();
                    break;
                case 18:
                    message.playerCurXp = reader.int32();
                    break;
                case 19:
                    message.playerXpBonusFlags = reader.int32();
                    break;
                case 20:
                    message.rankings.push(exports.PlayerRankingInfo.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientHello();
        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;
        message.ongoingmatch =
            object.ongoingmatch !== undefined && object.ongoingmatch !== null
                ? exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.fromPartial(object.ongoingmatch)
                : undefined;
        message.globalStats =
            object.globalStats !== undefined && object.globalStats !== null
                ? exports.GlobalStatistics.fromPartial(object.globalStats)
                : undefined;
        message.penaltySeconds = (_b = object.penaltySeconds) !== null && _b !== void 0 ? _b : 0;
        message.penaltyReason = (_c = object.penaltyReason) !== null && _c !== void 0 ? _c : 0;
        message.vacBanned = (_d = object.vacBanned) !== null && _d !== void 0 ? _d : 0;
        message.ranking =
            object.ranking !== undefined && object.ranking !== null
                ? exports.PlayerRankingInfo.fromPartial(object.ranking)
                : undefined;
        message.commendation =
            object.commendation !== undefined && object.commendation !== null
                ? exports.PlayerCommendationInfo.fromPartial(object.commendation)
                : undefined;
        message.medals =
            object.medals !== undefined && object.medals !== null
                ? exports.PlayerMedalsInfo.fromPartial(object.medals)
                : undefined;
        message.myCurrentEvent =
            object.myCurrentEvent !== undefined && object.myCurrentEvent !== null
                ? exports.TournamentEvent.fromPartial(object.myCurrentEvent)
                : undefined;
        message.myCurrentEventTeams =
            ((_e = object.myCurrentEventTeams) === null || _e === void 0 ? void 0 : _e.map(e => exports.TournamentTeam.fromPartial(e))) || [];
        message.myCurrentTeam =
            object.myCurrentTeam !== undefined && object.myCurrentTeam !== null
                ? exports.TournamentTeam.fromPartial(object.myCurrentTeam)
                : undefined;
        message.myCurrentEventStages =
            ((_f = object.myCurrentEventStages) === null || _f === void 0 ? void 0 : _f.map(e => exports.TournamentEvent.fromPartial(e))) ||
                [];
        message.surveyVote = (_g = object.surveyVote) !== null && _g !== void 0 ? _g : 0;
        message.activity =
            object.activity !== undefined && object.activity !== null
                ? exports.AccountActivity.fromPartial(object.activity)
                : undefined;
        message.playerLevel = (_h = object.playerLevel) !== null && _h !== void 0 ? _h : 0;
        message.playerCurXp = (_j = object.playerCurXp) !== null && _j !== void 0 ? _j : 0;
        message.playerXpBonusFlags = (_k = object.playerXpBonusFlags) !== null && _k !== void 0 ? _k : 0;
        message.rankings =
            ((_l = object.rankings) === null || _l === void 0 ? void 0 : _l.map(e => exports.PlayerRankingInfo.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2AccountPrivacySettings() {
    return { settings: [] };
}
exports.CMsgGCCStrike15V2AccountPrivacySettings = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.settings) {
            exports.CMsgGCCStrike15V2AccountPrivacySettings_Setting.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2AccountPrivacySettings();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.settings.push(exports.CMsgGCCStrike15V2AccountPrivacySettings_Setting.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2AccountPrivacySettings();
        message.settings =
            ((_a = object.settings) === null || _a === void 0 ? void 0 : _a.map(e => exports.CMsgGCCStrike15V2AccountPrivacySettings_Setting.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2AccountPrivacySettings_Setting() {
    return { settingType: 0, settingValue: 0 };
}
exports.CMsgGCCStrike15V2AccountPrivacySettings_Setting = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.settingType !== 0) {
            writer.uint32(8).uint32(message.settingType);
        }
        if (message.settingValue !== 0) {
            writer.uint32(16).uint32(message.settingValue);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2AccountPrivacySettings_Setting();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.settingType = reader.uint32();
                    break;
                case 2:
                    message.settingValue = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2AccountPrivacySettings_Setting();
        message.settingType = (_a = object.settingType) !== null && _a !== void 0 ? _a : 0;
        message.settingValue = (_b = object.settingValue) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchmakingGC2ClientAbandon() {
    return {
        accountId: 0,
        abandonedMatch: undefined,
        penaltySeconds: 0,
        penaltyReason: 0
    };
}
exports.CMsgGCCStrike15V2MatchmakingGC2ClientAbandon = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountId !== 0) {
            writer.uint32(8).uint32(message.accountId);
        }
        if (message.abandonedMatch !== undefined) {
            exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.encode(message.abandonedMatch, writer.uint32(18).fork()).ldelim();
        }
        if (message.penaltySeconds !== 0) {
            writer.uint32(24).uint32(message.penaltySeconds);
        }
        if (message.penaltyReason !== 0) {
            writer.uint32(32).uint32(message.penaltyReason);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientAbandon();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountId = reader.uint32();
                    break;
                case 2:
                    message.abandonedMatch =
                        exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.penaltySeconds = reader.uint32();
                    break;
                case 4:
                    message.penaltyReason = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientAbandon();
        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;
        message.abandonedMatch =
            object.abandonedMatch !== undefined && object.abandonedMatch !== null
                ? exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.fromPartial(object.abandonedMatch)
                : undefined;
        message.penaltySeconds = (_b = object.penaltySeconds) !== null && _b !== void 0 ? _b : 0;
        message.penaltyReason = (_c = object.penaltyReason) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientGCRankUpdate() {
    return { rankings: [] };
}
exports.CMsgGCCStrike15V2ClientGCRankUpdate = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.rankings) {
            exports.PlayerRankingInfo.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientGCRankUpdate();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.rankings.push(exports.PlayerRankingInfo.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2ClientGCRankUpdate();
        message.rankings =
            ((_a = object.rankings) === null || _a === void 0 ? void 0 : _a.map(e => exports.PlayerRankingInfo.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchmakingOperator2GCBlogUpdate() {
    return { mainPostUrl: "" };
}
exports.CMsgGCCStrike15V2MatchmakingOperator2GCBlogUpdate = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.mainPostUrl !== "") {
            writer.uint32(10).string(message.mainPostUrl);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchmakingOperator2GCBlogUpdate();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.mainPostUrl = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2MatchmakingOperator2GCBlogUpdate();
        message.mainPostUrl = (_a = object.mainPostUrl) !== null && _a !== void 0 ? _a : "";
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ServerNotificationForUserPenalty() {
    return { accountId: 0, reason: 0, seconds: 0, communicationCooldown: false };
}
exports.CMsgGCCStrike15V2ServerNotificationForUserPenalty = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountId !== 0) {
            writer.uint32(8).uint32(message.accountId);
        }
        if (message.reason !== 0) {
            writer.uint32(16).uint32(message.reason);
        }
        if (message.seconds !== 0) {
            writer.uint32(24).uint32(message.seconds);
        }
        if (message.communicationCooldown === true) {
            writer.uint32(32).bool(message.communicationCooldown);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ServerNotificationForUserPenalty();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountId = reader.uint32();
                    break;
                case 2:
                    message.reason = reader.uint32();
                    break;
                case 3:
                    message.seconds = reader.uint32();
                    break;
                case 4:
                    message.communicationCooldown = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCMsgGCCStrike15V2ServerNotificationForUserPenalty();
        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;
        message.reason = (_b = object.reason) !== null && _b !== void 0 ? _b : 0;
        message.seconds = (_c = object.seconds) !== null && _c !== void 0 ? _c : 0;
        message.communicationCooldown = (_d = object.communicationCooldown) !== null && _d !== void 0 ? _d : false;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientReportPlayer() {
    return {
        accountId: 0,
        rptAimbot: 0,
        rptWallhack: 0,
        rptSpeedhack: 0,
        rptTeamharm: 0,
        rptTextabuse: 0,
        rptVoiceabuse: 0,
        matchId: Long.UZERO,
        reportFromDemo: false
    };
}
exports.CMsgGCCStrike15V2ClientReportPlayer = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountId !== 0) {
            writer.uint32(8).uint32(message.accountId);
        }
        if (message.rptAimbot !== 0) {
            writer.uint32(16).uint32(message.rptAimbot);
        }
        if (message.rptWallhack !== 0) {
            writer.uint32(24).uint32(message.rptWallhack);
        }
        if (message.rptSpeedhack !== 0) {
            writer.uint32(32).uint32(message.rptSpeedhack);
        }
        if (message.rptTeamharm !== 0) {
            writer.uint32(40).uint32(message.rptTeamharm);
        }
        if (message.rptTextabuse !== 0) {
            writer.uint32(48).uint32(message.rptTextabuse);
        }
        if (message.rptVoiceabuse !== 0) {
            writer.uint32(56).uint32(message.rptVoiceabuse);
        }
        if (!message.matchId.isZero()) {
            writer.uint32(64).uint64(message.matchId);
        }
        if (message.reportFromDemo === true) {
            writer.uint32(72).bool(message.reportFromDemo);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientReportPlayer();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountId = reader.uint32();
                    break;
                case 2:
                    message.rptAimbot = reader.uint32();
                    break;
                case 3:
                    message.rptWallhack = reader.uint32();
                    break;
                case 4:
                    message.rptSpeedhack = reader.uint32();
                    break;
                case 5:
                    message.rptTeamharm = reader.uint32();
                    break;
                case 6:
                    message.rptTextabuse = reader.uint32();
                    break;
                case 7:
                    message.rptVoiceabuse = reader.uint32();
                    break;
                case 8:
                    message.matchId = reader.uint64();
                    break;
                case 9:
                    message.reportFromDemo = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h;
        const message = createBaseCMsgGCCStrike15V2ClientReportPlayer();
        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;
        message.rptAimbot = (_b = object.rptAimbot) !== null && _b !== void 0 ? _b : 0;
        message.rptWallhack = (_c = object.rptWallhack) !== null && _c !== void 0 ? _c : 0;
        message.rptSpeedhack = (_d = object.rptSpeedhack) !== null && _d !== void 0 ? _d : 0;
        message.rptTeamharm = (_e = object.rptTeamharm) !== null && _e !== void 0 ? _e : 0;
        message.rptTextabuse = (_f = object.rptTextabuse) !== null && _f !== void 0 ? _f : 0;
        message.rptVoiceabuse = (_g = object.rptVoiceabuse) !== null && _g !== void 0 ? _g : 0;
        message.matchId =
            object.matchId !== undefined && object.matchId !== null
                ? Long.fromValue(object.matchId)
                : Long.UZERO;
        message.reportFromDemo = (_h = object.reportFromDemo) !== null && _h !== void 0 ? _h : false;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientCommendPlayer() {
    return {
        accountId: 0,
        matchId: Long.UZERO,
        commendation: undefined,
        tokens: 0
    };
}
exports.CMsgGCCStrike15V2ClientCommendPlayer = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountId !== 0) {
            writer.uint32(8).uint32(message.accountId);
        }
        if (!message.matchId.isZero()) {
            writer.uint32(64).uint64(message.matchId);
        }
        if (message.commendation !== undefined) {
            exports.PlayerCommendationInfo.encode(message.commendation, writer.uint32(74).fork()).ldelim();
        }
        if (message.tokens !== 0) {
            writer.uint32(80).uint32(message.tokens);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientCommendPlayer();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountId = reader.uint32();
                    break;
                case 8:
                    message.matchId = reader.uint64();
                    break;
                case 9:
                    message.commendation = exports.PlayerCommendationInfo.decode(reader, reader.uint32());
                    break;
                case 10:
                    message.tokens = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2ClientCommendPlayer();
        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;
        message.matchId =
            object.matchId !== undefined && object.matchId !== null
                ? Long.fromValue(object.matchId)
                : Long.UZERO;
        message.commendation =
            object.commendation !== undefined && object.commendation !== null
                ? exports.PlayerCommendationInfo.fromPartial(object.commendation)
                : undefined;
        message.tokens = (_b = object.tokens) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientReportServer() {
    return {
        rptPoorperf: 0,
        rptAbusivemodels: 0,
        rptBadmotd: 0,
        rptListingabuse: 0,
        rptInventoryabuse: 0,
        matchId: Long.UZERO
    };
}
exports.CMsgGCCStrike15V2ClientReportServer = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.rptPoorperf !== 0) {
            writer.uint32(8).uint32(message.rptPoorperf);
        }
        if (message.rptAbusivemodels !== 0) {
            writer.uint32(16).uint32(message.rptAbusivemodels);
        }
        if (message.rptBadmotd !== 0) {
            writer.uint32(24).uint32(message.rptBadmotd);
        }
        if (message.rptListingabuse !== 0) {
            writer.uint32(32).uint32(message.rptListingabuse);
        }
        if (message.rptInventoryabuse !== 0) {
            writer.uint32(40).uint32(message.rptInventoryabuse);
        }
        if (!message.matchId.isZero()) {
            writer.uint32(64).uint64(message.matchId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientReportServer();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.rptPoorperf = reader.uint32();
                    break;
                case 2:
                    message.rptAbusivemodels = reader.uint32();
                    break;
                case 3:
                    message.rptBadmotd = reader.uint32();
                    break;
                case 4:
                    message.rptListingabuse = reader.uint32();
                    break;
                case 5:
                    message.rptInventoryabuse = reader.uint32();
                    break;
                case 8:
                    message.matchId = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseCMsgGCCStrike15V2ClientReportServer();
        message.rptPoorperf = (_a = object.rptPoorperf) !== null && _a !== void 0 ? _a : 0;
        message.rptAbusivemodels = (_b = object.rptAbusivemodels) !== null && _b !== void 0 ? _b : 0;
        message.rptBadmotd = (_c = object.rptBadmotd) !== null && _c !== void 0 ? _c : 0;
        message.rptListingabuse = (_d = object.rptListingabuse) !== null && _d !== void 0 ? _d : 0;
        message.rptInventoryabuse = (_e = object.rptInventoryabuse) !== null && _e !== void 0 ? _e : 0;
        message.matchId =
            object.matchId !== undefined && object.matchId !== null
                ? Long.fromValue(object.matchId)
                : Long.UZERO;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientReportResponse() {
    return {
        confirmationId: Long.UZERO,
        accountId: 0,
        serverIp: 0,
        responseType: 0,
        responseResult: 0,
        tokens: 0
    };
}
exports.CMsgGCCStrike15V2ClientReportResponse = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.confirmationId.isZero()) {
            writer.uint32(8).uint64(message.confirmationId);
        }
        if (message.accountId !== 0) {
            writer.uint32(16).uint32(message.accountId);
        }
        if (message.serverIp !== 0) {
            writer.uint32(24).uint32(message.serverIp);
        }
        if (message.responseType !== 0) {
            writer.uint32(32).uint32(message.responseType);
        }
        if (message.responseResult !== 0) {
            writer.uint32(40).uint32(message.responseResult);
        }
        if (message.tokens !== 0) {
            writer.uint32(48).uint32(message.tokens);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientReportResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.confirmationId = reader.uint64();
                    break;
                case 2:
                    message.accountId = reader.uint32();
                    break;
                case 3:
                    message.serverIp = reader.uint32();
                    break;
                case 4:
                    message.responseType = reader.uint32();
                    break;
                case 5:
                    message.responseResult = reader.uint32();
                    break;
                case 6:
                    message.tokens = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseCMsgGCCStrike15V2ClientReportResponse();
        message.confirmationId =
            object.confirmationId !== undefined && object.confirmationId !== null
                ? Long.fromValue(object.confirmationId)
                : Long.UZERO;
        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;
        message.serverIp = (_b = object.serverIp) !== null && _b !== void 0 ? _b : 0;
        message.responseType = (_c = object.responseType) !== null && _c !== void 0 ? _c : 0;
        message.responseResult = (_d = object.responseResult) !== null && _d !== void 0 ? _d : 0;
        message.tokens = (_e = object.tokens) !== null && _e !== void 0 ? _e : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientRequestWatchInfoFriends() {
    return {
        requestId: 0,
        accountIds: [],
        serverid: Long.UZERO,
        matchid: Long.UZERO,
        clientLauncher: 0,
        dataCenterPings: []
    };
}
exports.CMsgGCCStrike15V2ClientRequestWatchInfoFriends = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.requestId !== 0) {
            writer.uint32(8).uint32(message.requestId);
        }
        writer.uint32(18).fork();
        for (const v of message.accountIds) {
            writer.uint32(v);
        }
        writer.ldelim();
        if (!message.serverid.isZero()) {
            writer.uint32(24).uint64(message.serverid);
        }
        if (!message.matchid.isZero()) {
            writer.uint32(32).uint64(message.matchid);
        }
        if (message.clientLauncher !== 0) {
            writer.uint32(40).uint32(message.clientLauncher);
        }
        for (const v of message.dataCenterPings) {
            exports.DataCenterPing.encode(v, writer.uint32(50).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientRequestWatchInfoFriends();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.requestId = reader.uint32();
                    break;
                case 2:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.accountIds.push(reader.uint32());
                        }
                    }
                    else {
                        message.accountIds.push(reader.uint32());
                    }
                    break;
                case 3:
                    message.serverid = reader.uint64();
                    break;
                case 4:
                    message.matchid = reader.uint64();
                    break;
                case 5:
                    message.clientLauncher = reader.uint32();
                    break;
                case 6:
                    message.dataCenterPings.push(exports.DataCenterPing.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCMsgGCCStrike15V2ClientRequestWatchInfoFriends();
        message.requestId = (_a = object.requestId) !== null && _a !== void 0 ? _a : 0;
        message.accountIds = ((_b = object.accountIds) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];
        message.serverid =
            object.serverid !== undefined && object.serverid !== null
                ? Long.fromValue(object.serverid)
                : Long.UZERO;
        message.matchid =
            object.matchid !== undefined && object.matchid !== null
                ? Long.fromValue(object.matchid)
                : Long.UZERO;
        message.clientLauncher = (_c = object.clientLauncher) !== null && _c !== void 0 ? _c : 0;
        message.dataCenterPings =
            ((_d = object.dataCenterPings) === null || _d === void 0 ? void 0 : _d.map(e => exports.DataCenterPing.fromPartial(e))) || [];
        return message;
    }
};
function createBaseWatchableMatchInfo() {
    return {
        serverIp: 0,
        tvPort: 0,
        tvSpectators: 0,
        tvTime: 0,
        tvWatchPassword: new Uint8Array(),
        clDecryptdataKey: Long.UZERO,
        clDecryptdataKeyPub: Long.UZERO,
        gameType: 0,
        gameMapgroup: "",
        gameMap: "",
        serverId: Long.UZERO,
        matchId: Long.UZERO,
        reservationId: Long.UZERO
    };
}
exports.WatchableMatchInfo = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.serverIp !== 0) {
            writer.uint32(8).uint32(message.serverIp);
        }
        if (message.tvPort !== 0) {
            writer.uint32(16).uint32(message.tvPort);
        }
        if (message.tvSpectators !== 0) {
            writer.uint32(24).uint32(message.tvSpectators);
        }
        if (message.tvTime !== 0) {
            writer.uint32(32).uint32(message.tvTime);
        }
        if (message.tvWatchPassword.length !== 0) {
            writer.uint32(42).bytes(message.tvWatchPassword);
        }
        if (!message.clDecryptdataKey.isZero()) {
            writer.uint32(48).uint64(message.clDecryptdataKey);
        }
        if (!message.clDecryptdataKeyPub.isZero()) {
            writer.uint32(56).uint64(message.clDecryptdataKeyPub);
        }
        if (message.gameType !== 0) {
            writer.uint32(64).uint32(message.gameType);
        }
        if (message.gameMapgroup !== "") {
            writer.uint32(74).string(message.gameMapgroup);
        }
        if (message.gameMap !== "") {
            writer.uint32(82).string(message.gameMap);
        }
        if (!message.serverId.isZero()) {
            writer.uint32(88).uint64(message.serverId);
        }
        if (!message.matchId.isZero()) {
            writer.uint32(96).uint64(message.matchId);
        }
        if (!message.reservationId.isZero()) {
            writer.uint32(104).uint64(message.reservationId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseWatchableMatchInfo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.serverIp = reader.uint32();
                    break;
                case 2:
                    message.tvPort = reader.uint32();
                    break;
                case 3:
                    message.tvSpectators = reader.uint32();
                    break;
                case 4:
                    message.tvTime = reader.uint32();
                    break;
                case 5:
                    message.tvWatchPassword = reader.bytes();
                    break;
                case 6:
                    message.clDecryptdataKey = reader.uint64();
                    break;
                case 7:
                    message.clDecryptdataKeyPub = reader.uint64();
                    break;
                case 8:
                    message.gameType = reader.uint32();
                    break;
                case 9:
                    message.gameMapgroup = reader.string();
                    break;
                case 10:
                    message.gameMap = reader.string();
                    break;
                case 11:
                    message.serverId = reader.uint64();
                    break;
                case 12:
                    message.matchId = reader.uint64();
                    break;
                case 13:
                    message.reservationId = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h;
        const message = createBaseWatchableMatchInfo();
        message.serverIp = (_a = object.serverIp) !== null && _a !== void 0 ? _a : 0;
        message.tvPort = (_b = object.tvPort) !== null && _b !== void 0 ? _b : 0;
        message.tvSpectators = (_c = object.tvSpectators) !== null && _c !== void 0 ? _c : 0;
        message.tvTime = (_d = object.tvTime) !== null && _d !== void 0 ? _d : 0;
        message.tvWatchPassword = (_e = object.tvWatchPassword) !== null && _e !== void 0 ? _e : new Uint8Array();
        message.clDecryptdataKey =
            object.clDecryptdataKey !== undefined && object.clDecryptdataKey !== null
                ? Long.fromValue(object.clDecryptdataKey)
                : Long.UZERO;
        message.clDecryptdataKeyPub =
            object.clDecryptdataKeyPub !== undefined &&
                object.clDecryptdataKeyPub !== null
                ? Long.fromValue(object.clDecryptdataKeyPub)
                : Long.UZERO;
        message.gameType = (_f = object.gameType) !== null && _f !== void 0 ? _f : 0;
        message.gameMapgroup = (_g = object.gameMapgroup) !== null && _g !== void 0 ? _g : "";
        message.gameMap = (_h = object.gameMap) !== null && _h !== void 0 ? _h : "";
        message.serverId =
            object.serverId !== undefined && object.serverId !== null
                ? Long.fromValue(object.serverId)
                : Long.UZERO;
        message.matchId =
            object.matchId !== undefined && object.matchId !== null
                ? Long.fromValue(object.matchId)
                : Long.UZERO;
        message.reservationId =
            object.reservationId !== undefined && object.reservationId !== null
                ? Long.fromValue(object.reservationId)
                : Long.UZERO;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientRequestJoinFriendData() {
    return {
        version: 0,
        accountId: 0,
        joinToken: 0,
        joinIpp: 0,
        res: undefined,
        errormsg: ""
    };
}
exports.CMsgGCCStrike15V2ClientRequestJoinFriendData = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.version !== 0) {
            writer.uint32(8).uint32(message.version);
        }
        if (message.accountId !== 0) {
            writer.uint32(16).uint32(message.accountId);
        }
        if (message.joinToken !== 0) {
            writer.uint32(24).uint32(message.joinToken);
        }
        if (message.joinIpp !== 0) {
            writer.uint32(32).uint32(message.joinIpp);
        }
        if (message.res !== undefined) {
            exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.encode(message.res, writer.uint32(42).fork()).ldelim();
        }
        if (message.errormsg !== "") {
            writer.uint32(50).string(message.errormsg);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientRequestJoinFriendData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.version = reader.uint32();
                    break;
                case 2:
                    message.accountId = reader.uint32();
                    break;
                case 3:
                    message.joinToken = reader.uint32();
                    break;
                case 4:
                    message.joinIpp = reader.uint32();
                    break;
                case 5:
                    message.res = exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.decode(reader, reader.uint32());
                    break;
                case 6:
                    message.errormsg = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseCMsgGCCStrike15V2ClientRequestJoinFriendData();
        message.version = (_a = object.version) !== null && _a !== void 0 ? _a : 0;
        message.accountId = (_b = object.accountId) !== null && _b !== void 0 ? _b : 0;
        message.joinToken = (_c = object.joinToken) !== null && _c !== void 0 ? _c : 0;
        message.joinIpp = (_d = object.joinIpp) !== null && _d !== void 0 ? _d : 0;
        message.res =
            object.res !== undefined && object.res !== null
                ? exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.fromPartial(object.res)
                : undefined;
        message.errormsg = (_e = object.errormsg) !== null && _e !== void 0 ? _e : "";
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientRequestJoinServerData() {
    return {
        version: 0,
        accountId: 0,
        serverid: Long.UZERO,
        serverIp: 0,
        serverPort: 0,
        res: undefined,
        errormsg: ""
    };
}
exports.CMsgGCCStrike15V2ClientRequestJoinServerData = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.version !== 0) {
            writer.uint32(8).uint32(message.version);
        }
        if (message.accountId !== 0) {
            writer.uint32(16).uint32(message.accountId);
        }
        if (!message.serverid.isZero()) {
            writer.uint32(24).uint64(message.serverid);
        }
        if (message.serverIp !== 0) {
            writer.uint32(32).uint32(message.serverIp);
        }
        if (message.serverPort !== 0) {
            writer.uint32(40).uint32(message.serverPort);
        }
        if (message.res !== undefined) {
            exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.encode(message.res, writer.uint32(50).fork()).ldelim();
        }
        if (message.errormsg !== "") {
            writer.uint32(58).string(message.errormsg);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientRequestJoinServerData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.version = reader.uint32();
                    break;
                case 2:
                    message.accountId = reader.uint32();
                    break;
                case 3:
                    message.serverid = reader.uint64();
                    break;
                case 4:
                    message.serverIp = reader.uint32();
                    break;
                case 5:
                    message.serverPort = reader.uint32();
                    break;
                case 6:
                    message.res = exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.decode(reader, reader.uint32());
                    break;
                case 7:
                    message.errormsg = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseCMsgGCCStrike15V2ClientRequestJoinServerData();
        message.version = (_a = object.version) !== null && _a !== void 0 ? _a : 0;
        message.accountId = (_b = object.accountId) !== null && _b !== void 0 ? _b : 0;
        message.serverid =
            object.serverid !== undefined && object.serverid !== null
                ? Long.fromValue(object.serverid)
                : Long.UZERO;
        message.serverIp = (_c = object.serverIp) !== null && _c !== void 0 ? _c : 0;
        message.serverPort = (_d = object.serverPort) !== null && _d !== void 0 ? _d : 0;
        message.res =
            object.res !== undefined && object.res !== null
                ? exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.fromPartial(object.res)
                : undefined;
        message.errormsg = (_e = object.errormsg) !== null && _e !== void 0 ? _e : "";
        return message;
    }
};
function createBaseCMsgGCCstrike15V2ClientRequestNewMission() {
    return { missionId: 0, campaignId: 0 };
}
exports.CMsgGCCstrike15V2ClientRequestNewMission = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.missionId !== 0) {
            writer.uint32(16).uint32(message.missionId);
        }
        if (message.campaignId !== 0) {
            writer.uint32(24).uint32(message.campaignId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCstrike15V2ClientRequestNewMission();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 2:
                    message.missionId = reader.uint32();
                    break;
                case 3:
                    message.campaignId = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCstrike15V2ClientRequestNewMission();
        message.missionId = (_a = object.missionId) !== null && _a !== void 0 ? _a : 0;
        message.campaignId = (_b = object.campaignId) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCMsgGCCstrike15V2ClientRedeemMissionReward() {
    return { campaignId: 0, redeemId: 0, redeemableBalance: 0, expectedCost: 0 };
}
exports.CMsgGCCstrike15V2ClientRedeemMissionReward = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.campaignId !== 0) {
            writer.uint32(8).uint32(message.campaignId);
        }
        if (message.redeemId !== 0) {
            writer.uint32(16).uint32(message.redeemId);
        }
        if (message.redeemableBalance !== 0) {
            writer.uint32(24).uint32(message.redeemableBalance);
        }
        if (message.expectedCost !== 0) {
            writer.uint32(32).uint32(message.expectedCost);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCstrike15V2ClientRedeemMissionReward();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.campaignId = reader.uint32();
                    break;
                case 2:
                    message.redeemId = reader.uint32();
                    break;
                case 3:
                    message.redeemableBalance = reader.uint32();
                    break;
                case 4:
                    message.expectedCost = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCMsgGCCstrike15V2ClientRedeemMissionReward();
        message.campaignId = (_a = object.campaignId) !== null && _a !== void 0 ? _a : 0;
        message.redeemId = (_b = object.redeemId) !== null && _b !== void 0 ? _b : 0;
        message.redeemableBalance = (_c = object.redeemableBalance) !== null && _c !== void 0 ? _c : 0;
        message.expectedCost = (_d = object.expectedCost) !== null && _d !== void 0 ? _d : 0;
        return message;
    }
};
function createBaseCMsgGCCstrike15V2GC2ServerNotifyXPRewarded() {
    return {
        xpProgressData: [],
        accountId: 0,
        currentXp: 0,
        currentLevel: 0,
        upgradedDefidx: 0,
        operationPointsAwarded: 0
    };
}
exports.CMsgGCCstrike15V2GC2ServerNotifyXPRewarded = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.xpProgressData) {
            exports.XpProgressData.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.accountId !== 0) {
            writer.uint32(16).uint32(message.accountId);
        }
        if (message.currentXp !== 0) {
            writer.uint32(24).uint32(message.currentXp);
        }
        if (message.currentLevel !== 0) {
            writer.uint32(32).uint32(message.currentLevel);
        }
        if (message.upgradedDefidx !== 0) {
            writer.uint32(40).uint32(message.upgradedDefidx);
        }
        if (message.operationPointsAwarded !== 0) {
            writer.uint32(48).uint32(message.operationPointsAwarded);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCstrike15V2GC2ServerNotifyXPRewarded();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.xpProgressData.push(exports.XpProgressData.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.accountId = reader.uint32();
                    break;
                case 3:
                    message.currentXp = reader.uint32();
                    break;
                case 4:
                    message.currentLevel = reader.uint32();
                    break;
                case 5:
                    message.upgradedDefidx = reader.uint32();
                    break;
                case 6:
                    message.operationPointsAwarded = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f;
        const message = createBaseCMsgGCCstrike15V2GC2ServerNotifyXPRewarded();
        message.xpProgressData =
            ((_a = object.xpProgressData) === null || _a === void 0 ? void 0 : _a.map(e => exports.XpProgressData.fromPartial(e))) || [];
        message.accountId = (_b = object.accountId) !== null && _b !== void 0 ? _b : 0;
        message.currentXp = (_c = object.currentXp) !== null && _c !== void 0 ? _c : 0;
        message.currentLevel = (_d = object.currentLevel) !== null && _d !== void 0 ? _d : 0;
        message.upgradedDefidx = (_e = object.upgradedDefidx) !== null && _e !== void 0 ? _e : 0;
        message.operationPointsAwarded = (_f = object.operationPointsAwarded) !== null && _f !== void 0 ? _f : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15ClientDeepStats() {
    return { accountId: 0, range: undefined, matches: [] };
}
exports.CMsgGCCStrike15ClientDeepStats = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountId !== 0) {
            writer.uint32(8).uint32(message.accountId);
        }
        if (message.range !== undefined) {
            exports.CMsgGCCStrike15ClientDeepStats_DeepStatsRange.encode(message.range, writer.uint32(18).fork()).ldelim();
        }
        for (const v of message.matches) {
            exports.CMsgGCCStrike15ClientDeepStats_DeepStatsMatch.encode(v, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15ClientDeepStats();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountId = reader.uint32();
                    break;
                case 2:
                    message.range = exports.CMsgGCCStrike15ClientDeepStats_DeepStatsRange.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.matches.push(exports.CMsgGCCStrike15ClientDeepStats_DeepStatsMatch.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15ClientDeepStats();
        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;
        message.range =
            object.range !== undefined && object.range !== null
                ? exports.CMsgGCCStrike15ClientDeepStats_DeepStatsRange.fromPartial(object.range)
                : undefined;
        message.matches =
            ((_b = object.matches) === null || _b === void 0 ? void 0 : _b.map(e => exports.CMsgGCCStrike15ClientDeepStats_DeepStatsMatch.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15ClientDeepStats_DeepStatsRange() {
    return { begin: 0, end: 0, frozen: false };
}
exports.CMsgGCCStrike15ClientDeepStats_DeepStatsRange = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.begin !== 0) {
            writer.uint32(8).uint32(message.begin);
        }
        if (message.end !== 0) {
            writer.uint32(16).uint32(message.end);
        }
        if (message.frozen === true) {
            writer.uint32(24).bool(message.frozen);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15ClientDeepStats_DeepStatsRange();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.begin = reader.uint32();
                    break;
                case 2:
                    message.end = reader.uint32();
                    break;
                case 3:
                    message.frozen = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCMsgGCCStrike15ClientDeepStats_DeepStatsRange();
        message.begin = (_a = object.begin) !== null && _a !== void 0 ? _a : 0;
        message.end = (_b = object.end) !== null && _b !== void 0 ? _b : 0;
        message.frozen = (_c = object.frozen) !== null && _c !== void 0 ? _c : false;
        return message;
    }
};
function createBaseCMsgGCCStrike15ClientDeepStats_DeepStatsMatch() {
    return { player: undefined, events: [] };
}
exports.CMsgGCCStrike15ClientDeepStats_DeepStatsMatch = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.player !== undefined) {
            exports.DeepPlayerStatsEntry.encode(message.player, writer.uint32(10).fork()).ldelim();
        }
        for (const v of message.events) {
            exports.DeepPlayerMatchEvent.encode(v, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15ClientDeepStats_DeepStatsMatch();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.player = exports.DeepPlayerStatsEntry.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.events.push(exports.DeepPlayerMatchEvent.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15ClientDeepStats_DeepStatsMatch();
        message.player =
            object.player !== undefined && object.player !== null
                ? exports.DeepPlayerStatsEntry.fromPartial(object.player)
                : undefined;
        message.events =
            ((_a = object.events) === null || _a === void 0 ? void 0 : _a.map(e => exports.DeepPlayerMatchEvent.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2WatchInfoUsers() {
    return {
        requestId: 0,
        accountIds: [],
        watchableMatchInfos: [],
        extendedTimeout: 0
    };
}
exports.CMsgGCCStrike15V2WatchInfoUsers = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.requestId !== 0) {
            writer.uint32(8).uint32(message.requestId);
        }
        writer.uint32(18).fork();
        for (const v of message.accountIds) {
            writer.uint32(v);
        }
        writer.ldelim();
        for (const v of message.watchableMatchInfos) {
            exports.WatchableMatchInfo.encode(v, writer.uint32(26).fork()).ldelim();
        }
        if (message.extendedTimeout !== 0) {
            writer.uint32(40).uint32(message.extendedTimeout);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2WatchInfoUsers();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.requestId = reader.uint32();
                    break;
                case 2:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.accountIds.push(reader.uint32());
                        }
                    }
                    else {
                        message.accountIds.push(reader.uint32());
                    }
                    break;
                case 3:
                    message.watchableMatchInfos.push(exports.WatchableMatchInfo.decode(reader, reader.uint32()));
                    break;
                case 5:
                    message.extendedTimeout = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCMsgGCCStrike15V2WatchInfoUsers();
        message.requestId = (_a = object.requestId) !== null && _a !== void 0 ? _a : 0;
        message.accountIds = ((_b = object.accountIds) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];
        message.watchableMatchInfos =
            ((_c = object.watchableMatchInfos) === null || _c === void 0 ? void 0 : _c.map(e => exports.WatchableMatchInfo.fromPartial(e))) ||
                [];
        message.extendedTimeout = (_d = object.extendedTimeout) !== null && _d !== void 0 ? _d : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientRequestPlayersProfile() {
    return {
        requestIdDeprecated: 0,
        accountIdsDeprecated: [],
        accountId: 0,
        requestLevel: 0
    };
}
exports.CMsgGCCStrike15V2ClientRequestPlayersProfile = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.requestIdDeprecated !== 0) {
            writer.uint32(8).uint32(message.requestIdDeprecated);
        }
        writer.uint32(18).fork();
        for (const v of message.accountIdsDeprecated) {
            writer.uint32(v);
        }
        writer.ldelim();
        if (message.accountId !== 0) {
            writer.uint32(24).uint32(message.accountId);
        }
        if (message.requestLevel !== 0) {
            writer.uint32(32).uint32(message.requestLevel);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientRequestPlayersProfile();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.requestIdDeprecated = reader.uint32();
                    break;
                case 2:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.accountIdsDeprecated.push(reader.uint32());
                        }
                    }
                    else {
                        message.accountIdsDeprecated.push(reader.uint32());
                    }
                    break;
                case 3:
                    message.accountId = reader.uint32();
                    break;
                case 4:
                    message.requestLevel = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCMsgGCCStrike15V2ClientRequestPlayersProfile();
        message.requestIdDeprecated = (_a = object.requestIdDeprecated) !== null && _a !== void 0 ? _a : 0;
        message.accountIdsDeprecated =
            ((_b = object.accountIdsDeprecated) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];
        message.accountId = (_c = object.accountId) !== null && _c !== void 0 ? _c : 0;
        message.requestLevel = (_d = object.requestLevel) !== null && _d !== void 0 ? _d : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2PlayersProfile() {
    return { requestId: 0, accountProfiles: [] };
}
exports.CMsgGCCStrike15V2PlayersProfile = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.requestId !== 0) {
            writer.uint32(8).uint32(message.requestId);
        }
        for (const v of message.accountProfiles) {
            exports.CMsgGCCStrike15V2MatchmakingGC2ClientHello.encode(v, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2PlayersProfile();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.requestId = reader.uint32();
                    break;
                case 2:
                    message.accountProfiles.push(exports.CMsgGCCStrike15V2MatchmakingGC2ClientHello.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2PlayersProfile();
        message.requestId = (_a = object.requestId) !== null && _a !== void 0 ? _a : 0;
        message.accountProfiles =
            ((_b = object.accountProfiles) === null || _b === void 0 ? void 0 : _b.map(e => exports.CMsgGCCStrike15V2MatchmakingGC2ClientHello.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2PlayerOverwatchCaseUpdate() {
    return {
        caseid: Long.UZERO,
        suspectid: 0,
        fractionid: 0,
        rptAimbot: 0,
        rptWallhack: 0,
        rptSpeedhack: 0,
        rptTeamharm: 0,
        reason: 0
    };
}
exports.CMsgGCCStrike15V2PlayerOverwatchCaseUpdate = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.caseid.isZero()) {
            writer.uint32(8).uint64(message.caseid);
        }
        if (message.suspectid !== 0) {
            writer.uint32(24).uint32(message.suspectid);
        }
        if (message.fractionid !== 0) {
            writer.uint32(32).uint32(message.fractionid);
        }
        if (message.rptAimbot !== 0) {
            writer.uint32(40).uint32(message.rptAimbot);
        }
        if (message.rptWallhack !== 0) {
            writer.uint32(48).uint32(message.rptWallhack);
        }
        if (message.rptSpeedhack !== 0) {
            writer.uint32(56).uint32(message.rptSpeedhack);
        }
        if (message.rptTeamharm !== 0) {
            writer.uint32(64).uint32(message.rptTeamharm);
        }
        if (message.reason !== 0) {
            writer.uint32(72).uint32(message.reason);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2PlayerOverwatchCaseUpdate();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.caseid = reader.uint64();
                    break;
                case 3:
                    message.suspectid = reader.uint32();
                    break;
                case 4:
                    message.fractionid = reader.uint32();
                    break;
                case 5:
                    message.rptAimbot = reader.uint32();
                    break;
                case 6:
                    message.rptWallhack = reader.uint32();
                    break;
                case 7:
                    message.rptSpeedhack = reader.uint32();
                    break;
                case 8:
                    message.rptTeamharm = reader.uint32();
                    break;
                case 9:
                    message.reason = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g;
        const message = createBaseCMsgGCCStrike15V2PlayerOverwatchCaseUpdate();
        message.caseid =
            object.caseid !== undefined && object.caseid !== null
                ? Long.fromValue(object.caseid)
                : Long.UZERO;
        message.suspectid = (_a = object.suspectid) !== null && _a !== void 0 ? _a : 0;
        message.fractionid = (_b = object.fractionid) !== null && _b !== void 0 ? _b : 0;
        message.rptAimbot = (_c = object.rptAimbot) !== null && _c !== void 0 ? _c : 0;
        message.rptWallhack = (_d = object.rptWallhack) !== null && _d !== void 0 ? _d : 0;
        message.rptSpeedhack = (_e = object.rptSpeedhack) !== null && _e !== void 0 ? _e : 0;
        message.rptTeamharm = (_f = object.rptTeamharm) !== null && _f !== void 0 ? _f : 0;
        message.reason = (_g = object.reason) !== null && _g !== void 0 ? _g : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2PlayerOverwatchCaseAssignment() {
    return {
        caseid: Long.UZERO,
        caseurl: "",
        verdict: 0,
        timestamp: 0,
        throttleseconds: 0,
        suspectid: 0,
        fractionid: 0,
        numrounds: 0,
        fractionrounds: 0,
        streakconvictions: 0,
        reason: 0
    };
}
exports.CMsgGCCStrike15V2PlayerOverwatchCaseAssignment = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.caseid.isZero()) {
            writer.uint32(8).uint64(message.caseid);
        }
        if (message.caseurl !== "") {
            writer.uint32(18).string(message.caseurl);
        }
        if (message.verdict !== 0) {
            writer.uint32(24).uint32(message.verdict);
        }
        if (message.timestamp !== 0) {
            writer.uint32(32).uint32(message.timestamp);
        }
        if (message.throttleseconds !== 0) {
            writer.uint32(40).uint32(message.throttleseconds);
        }
        if (message.suspectid !== 0) {
            writer.uint32(48).uint32(message.suspectid);
        }
        if (message.fractionid !== 0) {
            writer.uint32(56).uint32(message.fractionid);
        }
        if (message.numrounds !== 0) {
            writer.uint32(64).uint32(message.numrounds);
        }
        if (message.fractionrounds !== 0) {
            writer.uint32(72).uint32(message.fractionrounds);
        }
        if (message.streakconvictions !== 0) {
            writer.uint32(80).int32(message.streakconvictions);
        }
        if (message.reason !== 0) {
            writer.uint32(88).uint32(message.reason);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2PlayerOverwatchCaseAssignment();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.caseid = reader.uint64();
                    break;
                case 2:
                    message.caseurl = reader.string();
                    break;
                case 3:
                    message.verdict = reader.uint32();
                    break;
                case 4:
                    message.timestamp = reader.uint32();
                    break;
                case 5:
                    message.throttleseconds = reader.uint32();
                    break;
                case 6:
                    message.suspectid = reader.uint32();
                    break;
                case 7:
                    message.fractionid = reader.uint32();
                    break;
                case 8:
                    message.numrounds = reader.uint32();
                    break;
                case 9:
                    message.fractionrounds = reader.uint32();
                    break;
                case 10:
                    message.streakconvictions = reader.int32();
                    break;
                case 11:
                    message.reason = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
        const message = createBaseCMsgGCCStrike15V2PlayerOverwatchCaseAssignment();
        message.caseid =
            object.caseid !== undefined && object.caseid !== null
                ? Long.fromValue(object.caseid)
                : Long.UZERO;
        message.caseurl = (_a = object.caseurl) !== null && _a !== void 0 ? _a : "";
        message.verdict = (_b = object.verdict) !== null && _b !== void 0 ? _b : 0;
        message.timestamp = (_c = object.timestamp) !== null && _c !== void 0 ? _c : 0;
        message.throttleseconds = (_d = object.throttleseconds) !== null && _d !== void 0 ? _d : 0;
        message.suspectid = (_e = object.suspectid) !== null && _e !== void 0 ? _e : 0;
        message.fractionid = (_f = object.fractionid) !== null && _f !== void 0 ? _f : 0;
        message.numrounds = (_g = object.numrounds) !== null && _g !== void 0 ? _g : 0;
        message.fractionrounds = (_h = object.fractionrounds) !== null && _h !== void 0 ? _h : 0;
        message.streakconvictions = (_j = object.streakconvictions) !== null && _j !== void 0 ? _j : 0;
        message.reason = (_k = object.reason) !== null && _k !== void 0 ? _k : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2PlayerOverwatchCaseStatus() {
    return { caseid: Long.UZERO, statusid: 0 };
}
exports.CMsgGCCStrike15V2PlayerOverwatchCaseStatus = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.caseid.isZero()) {
            writer.uint32(8).uint64(message.caseid);
        }
        if (message.statusid !== 0) {
            writer.uint32(16).uint32(message.statusid);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2PlayerOverwatchCaseStatus();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.caseid = reader.uint64();
                    break;
                case 2:
                    message.statusid = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2PlayerOverwatchCaseStatus();
        message.caseid =
            object.caseid !== undefined && object.caseid !== null
                ? Long.fromValue(object.caseid)
                : Long.UZERO;
        message.statusid = (_a = object.statusid) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCClientHeaderOverwatchEvidence() {
    return { accountid: 0, caseid: Long.UZERO };
}
exports.CClientHeaderOverwatchEvidence = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountid !== 0) {
            writer.uint32(8).uint32(message.accountid);
        }
        if (!message.caseid.isZero()) {
            writer.uint32(16).uint64(message.caseid);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCClientHeaderOverwatchEvidence();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountid = reader.uint32();
                    break;
                case 2:
                    message.caseid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCClientHeaderOverwatchEvidence();
        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;
        message.caseid =
            object.caseid !== undefined && object.caseid !== null
                ? Long.fromValue(object.caseid)
                : Long.UZERO;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2GC2ClientTextMsg() {
    return { id: 0, type: 0, payload: new Uint8Array() };
}
exports.CMsgGCCStrike15V2GC2ClientTextMsg = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.id !== 0) {
            writer.uint32(8).uint32(message.id);
        }
        if (message.type !== 0) {
            writer.uint32(16).uint32(message.type);
        }
        if (message.payload.length !== 0) {
            writer.uint32(26).bytes(message.payload);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2GC2ClientTextMsg();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.id = reader.uint32();
                    break;
                case 2:
                    message.type = reader.uint32();
                    break;
                case 3:
                    message.payload = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCMsgGCCStrike15V2GC2ClientTextMsg();
        message.id = (_a = object.id) !== null && _a !== void 0 ? _a : 0;
        message.type = (_b = object.type) !== null && _b !== void 0 ? _b : 0;
        message.payload = (_c = object.payload) !== null && _c !== void 0 ? _c : new Uint8Array();
        return message;
    }
};
function createBaseCMsgGCCStrike15V2Client2GCTextMsg() {
    return { id: 0, args: [] };
}
exports.CMsgGCCStrike15V2Client2GCTextMsg = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.id !== 0) {
            writer.uint32(8).uint32(message.id);
        }
        for (const v of message.args) {
            writer.uint32(18).bytes(v);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2Client2GCTextMsg();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.id = reader.uint32();
                    break;
                case 2:
                    message.args.push(reader.bytes());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2Client2GCTextMsg();
        message.id = (_a = object.id) !== null && _a !== void 0 ? _a : 0;
        message.args = ((_b = object.args) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchEndRunRewardDrops() {
    return { serverinfo: undefined, matchEndQuestData: undefined };
}
exports.CMsgGCCStrike15V2MatchEndRunRewardDrops = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.serverinfo !== undefined) {
            exports.CMsgGCCStrike15V2MatchmakingServerReservationResponse.encode(message.serverinfo, writer.uint32(26).fork()).ldelim();
        }
        if (message.matchEndQuestData !== undefined) {
            exports.CMsgGCServerQuestUpdateData.encode(message.matchEndQuestData, writer.uint32(34).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchEndRunRewardDrops();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 3:
                    message.serverinfo =
                        exports.CMsgGCCStrike15V2MatchmakingServerReservationResponse.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.matchEndQuestData = exports.CMsgGCServerQuestUpdateData.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCMsgGCCStrike15V2MatchEndRunRewardDrops();
        message.serverinfo =
            object.serverinfo !== undefined && object.serverinfo !== null
                ? exports.CMsgGCCStrike15V2MatchmakingServerReservationResponse.fromPartial(object.serverinfo)
                : undefined;
        message.matchEndQuestData =
            object.matchEndQuestData !== undefined &&
                object.matchEndQuestData !== null
                ? exports.CMsgGCServerQuestUpdateData.fromPartial(object.matchEndQuestData)
                : undefined;
        return message;
    }
};
function createBaseCEconItemPreviewDataBlock() {
    return {
        accountid: 0,
        itemid: Long.UZERO,
        defindex: 0,
        paintindex: 0,
        rarity: 0,
        quality: 0,
        paintwear: 0,
        paintseed: 0,
        killeaterscoretype: 0,
        killeatervalue: 0,
        customname: "",
        stickers: [],
        inventory: 0,
        origin: 0,
        questid: 0,
        dropreason: 0,
        musicindex: 0,
        entindex: 0
    };
}
exports.CEconItemPreviewDataBlock = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountid !== 0) {
            writer.uint32(8).uint32(message.accountid);
        }
        if (!message.itemid.isZero()) {
            writer.uint32(16).uint64(message.itemid);
        }
        if (message.defindex !== 0) {
            writer.uint32(24).uint32(message.defindex);
        }
        if (message.paintindex !== 0) {
            writer.uint32(32).uint32(message.paintindex);
        }
        if (message.rarity !== 0) {
            writer.uint32(40).uint32(message.rarity);
        }
        if (message.quality !== 0) {
            writer.uint32(48).uint32(message.quality);
        }
        if (message.paintwear !== 0) {
            writer.uint32(56).uint32(message.paintwear);
        }
        if (message.paintseed !== 0) {
            writer.uint32(64).uint32(message.paintseed);
        }
        if (message.killeaterscoretype !== 0) {
            writer.uint32(72).uint32(message.killeaterscoretype);
        }
        if (message.killeatervalue !== 0) {
            writer.uint32(80).uint32(message.killeatervalue);
        }
        if (message.customname !== "") {
            writer.uint32(90).string(message.customname);
        }
        for (const v of message.stickers) {
            exports.CEconItemPreviewDataBlock_Sticker.encode(v, writer.uint32(98).fork()).ldelim();
        }
        if (message.inventory !== 0) {
            writer.uint32(104).uint32(message.inventory);
        }
        if (message.origin !== 0) {
            writer.uint32(112).uint32(message.origin);
        }
        if (message.questid !== 0) {
            writer.uint32(120).uint32(message.questid);
        }
        if (message.dropreason !== 0) {
            writer.uint32(128).uint32(message.dropreason);
        }
        if (message.musicindex !== 0) {
            writer.uint32(136).uint32(message.musicindex);
        }
        if (message.entindex !== 0) {
            writer.uint32(144).int32(message.entindex);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCEconItemPreviewDataBlock();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountid = reader.uint32();
                    break;
                case 2:
                    message.itemid = reader.uint64();
                    break;
                case 3:
                    message.defindex = reader.uint32();
                    break;
                case 4:
                    message.paintindex = reader.uint32();
                    break;
                case 5:
                    message.rarity = reader.uint32();
                    break;
                case 6:
                    message.quality = reader.uint32();
                    break;
                case 7:
                    message.paintwear = reader.uint32();
                    break;
                case 8:
                    message.paintseed = reader.uint32();
                    break;
                case 9:
                    message.killeaterscoretype = reader.uint32();
                    break;
                case 10:
                    message.killeatervalue = reader.uint32();
                    break;
                case 11:
                    message.customname = reader.string();
                    break;
                case 12:
                    message.stickers.push(exports.CEconItemPreviewDataBlock_Sticker.decode(reader, reader.uint32()));
                    break;
                case 13:
                    message.inventory = reader.uint32();
                    break;
                case 14:
                    message.origin = reader.uint32();
                    break;
                case 15:
                    message.questid = reader.uint32();
                    break;
                case 16:
                    message.dropreason = reader.uint32();
                    break;
                case 17:
                    message.musicindex = reader.uint32();
                    break;
                case 18:
                    message.entindex = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
        const message = createBaseCEconItemPreviewDataBlock();
        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;
        message.itemid =
            object.itemid !== undefined && object.itemid !== null
                ? Long.fromValue(object.itemid)
                : Long.UZERO;
        message.defindex = (_b = object.defindex) !== null && _b !== void 0 ? _b : 0;
        message.paintindex = (_c = object.paintindex) !== null && _c !== void 0 ? _c : 0;
        message.rarity = (_d = object.rarity) !== null && _d !== void 0 ? _d : 0;
        message.quality = (_e = object.quality) !== null && _e !== void 0 ? _e : 0;
        message.paintwear = (_f = object.paintwear) !== null && _f !== void 0 ? _f : 0;
        message.paintseed = (_g = object.paintseed) !== null && _g !== void 0 ? _g : 0;
        message.killeaterscoretype = (_h = object.killeaterscoretype) !== null && _h !== void 0 ? _h : 0;
        message.killeatervalue = (_j = object.killeatervalue) !== null && _j !== void 0 ? _j : 0;
        message.customname = (_k = object.customname) !== null && _k !== void 0 ? _k : "";
        message.stickers =
            ((_l = object.stickers) === null || _l === void 0 ? void 0 : _l.map(e => exports.CEconItemPreviewDataBlock_Sticker.fromPartial(e))) || [];
        message.inventory = (_m = object.inventory) !== null && _m !== void 0 ? _m : 0;
        message.origin = (_o = object.origin) !== null && _o !== void 0 ? _o : 0;
        message.questid = (_p = object.questid) !== null && _p !== void 0 ? _p : 0;
        message.dropreason = (_q = object.dropreason) !== null && _q !== void 0 ? _q : 0;
        message.musicindex = (_r = object.musicindex) !== null && _r !== void 0 ? _r : 0;
        message.entindex = (_s = object.entindex) !== null && _s !== void 0 ? _s : 0;
        return message;
    }
};
function createBaseCEconItemPreviewDataBlock_Sticker() {
    return { slot: 0, stickerId: 0, wear: 0, scale: 0, rotation: 0, tintId: 0 };
}
exports.CEconItemPreviewDataBlock_Sticker = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.slot !== 0) {
            writer.uint32(8).uint32(message.slot);
        }
        if (message.stickerId !== 0) {
            writer.uint32(16).uint32(message.stickerId);
        }
        if (message.wear !== 0) {
            writer.uint32(29).float(message.wear);
        }
        if (message.scale !== 0) {
            writer.uint32(37).float(message.scale);
        }
        if (message.rotation !== 0) {
            writer.uint32(45).float(message.rotation);
        }
        if (message.tintId !== 0) {
            writer.uint32(48).uint32(message.tintId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCEconItemPreviewDataBlock_Sticker();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.slot = reader.uint32();
                    break;
                case 2:
                    message.stickerId = reader.uint32();
                    break;
                case 3:
                    message.wear = reader.float();
                    break;
                case 4:
                    message.scale = reader.float();
                    break;
                case 5:
                    message.rotation = reader.float();
                    break;
                case 6:
                    message.tintId = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f;
        const message = createBaseCEconItemPreviewDataBlock_Sticker();
        message.slot = (_a = object.slot) !== null && _a !== void 0 ? _a : 0;
        message.stickerId = (_b = object.stickerId) !== null && _b !== void 0 ? _b : 0;
        message.wear = (_c = object.wear) !== null && _c !== void 0 ? _c : 0;
        message.scale = (_d = object.scale) !== null && _d !== void 0 ? _d : 0;
        message.rotation = (_e = object.rotation) !== null && _e !== void 0 ? _e : 0;
        message.tintId = (_f = object.tintId) !== null && _f !== void 0 ? _f : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchEndRewardDropsNotification() {
    return { iteminfo: undefined };
}
exports.CMsgGCCStrike15V2MatchEndRewardDropsNotification = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.iteminfo !== undefined) {
            exports.CEconItemPreviewDataBlock.encode(message.iteminfo, writer.uint32(50).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchEndRewardDropsNotification();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 6:
                    message.iteminfo = exports.CEconItemPreviewDataBlock.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCMsgGCCStrike15V2MatchEndRewardDropsNotification();
        message.iteminfo =
            object.iteminfo !== undefined && object.iteminfo !== null
                ? exports.CEconItemPreviewDataBlock.fromPartial(object.iteminfo)
                : undefined;
        return message;
    }
};
function createBaseCMsgItemAcknowledged() {
    return { iteminfo: undefined };
}
exports.CMsgItemAcknowledged = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.iteminfo !== undefined) {
            exports.CEconItemPreviewDataBlock.encode(message.iteminfo, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgItemAcknowledged();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.iteminfo = exports.CEconItemPreviewDataBlock.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCMsgItemAcknowledged();
        message.iteminfo =
            object.iteminfo !== undefined && object.iteminfo !== null
                ? exports.CEconItemPreviewDataBlock.fromPartial(object.iteminfo)
                : undefined;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2Client2GCEconPreviewDataBlockRequest() {
    return {
        paramS: Long.UZERO,
        paramA: Long.UZERO,
        paramD: Long.UZERO,
        paramM: Long.UZERO
    };
}
exports.CMsgGCCStrike15V2Client2GCEconPreviewDataBlockRequest = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.paramS.isZero()) {
            writer.uint32(8).uint64(message.paramS);
        }
        if (!message.paramA.isZero()) {
            writer.uint32(16).uint64(message.paramA);
        }
        if (!message.paramD.isZero()) {
            writer.uint32(24).uint64(message.paramD);
        }
        if (!message.paramM.isZero()) {
            writer.uint32(32).uint64(message.paramM);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2Client2GCEconPreviewDataBlockRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.paramS = reader.uint64();
                    break;
                case 2:
                    message.paramA = reader.uint64();
                    break;
                case 3:
                    message.paramD = reader.uint64();
                    break;
                case 4:
                    message.paramM = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCMsgGCCStrike15V2Client2GCEconPreviewDataBlockRequest();
        message.paramS =
            object.paramS !== undefined && object.paramS !== null
                ? Long.fromValue(object.paramS)
                : Long.UZERO;
        message.paramA =
            object.paramA !== undefined && object.paramA !== null
                ? Long.fromValue(object.paramA)
                : Long.UZERO;
        message.paramD =
            object.paramD !== undefined && object.paramD !== null
                ? Long.fromValue(object.paramD)
                : Long.UZERO;
        message.paramM =
            object.paramM !== undefined && object.paramM !== null
                ? Long.fromValue(object.paramM)
                : Long.UZERO;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2Client2GCEconPreviewDataBlockResponse() {
    return { iteminfo: undefined };
}
exports.CMsgGCCStrike15V2Client2GCEconPreviewDataBlockResponse = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.iteminfo !== undefined) {
            exports.CEconItemPreviewDataBlock.encode(message.iteminfo, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2Client2GCEconPreviewDataBlockResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.iteminfo = exports.CEconItemPreviewDataBlock.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCMsgGCCStrike15V2Client2GCEconPreviewDataBlockResponse();
        message.iteminfo =
            object.iteminfo !== undefined && object.iteminfo !== null
                ? exports.CEconItemPreviewDataBlock.fromPartial(object.iteminfo)
                : undefined;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchListRequestCurrentLiveGames() {
    return {};
}
exports.CMsgGCCStrike15V2MatchListRequestCurrentLiveGames = {
    encode(_, writer = minimal_1.Writer.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchListRequestCurrentLiveGames();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseCMsgGCCStrike15V2MatchListRequestCurrentLiveGames();
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchListRequestLiveGameForUser() {
    return { accountid: 0 };
}
exports.CMsgGCCStrike15V2MatchListRequestLiveGameForUser = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountid !== 0) {
            writer.uint32(8).uint32(message.accountid);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchListRequestLiveGameForUser();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountid = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2MatchListRequestLiveGameForUser();
        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchListRequestRecentUserGames() {
    return { accountid: 0 };
}
exports.CMsgGCCStrike15V2MatchListRequestRecentUserGames = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountid !== 0) {
            writer.uint32(8).uint32(message.accountid);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchListRequestRecentUserGames();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountid = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2MatchListRequestRecentUserGames();
        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchListRequestTournamentGames() {
    return { eventid: 0 };
}
exports.CMsgGCCStrike15V2MatchListRequestTournamentGames = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.eventid !== 0) {
            writer.uint32(8).int32(message.eventid);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchListRequestTournamentGames();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.eventid = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2MatchListRequestTournamentGames();
        message.eventid = (_a = object.eventid) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchListRequestFullGameInfo() {
    return { matchid: Long.UZERO, outcomeid: Long.UZERO, token: 0 };
}
exports.CMsgGCCStrike15V2MatchListRequestFullGameInfo = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.matchid.isZero()) {
            writer.uint32(8).uint64(message.matchid);
        }
        if (!message.outcomeid.isZero()) {
            writer.uint32(16).uint64(message.outcomeid);
        }
        if (message.token !== 0) {
            writer.uint32(24).uint32(message.token);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchListRequestFullGameInfo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.matchid = reader.uint64();
                    break;
                case 2:
                    message.outcomeid = reader.uint64();
                    break;
                case 3:
                    message.token = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2MatchListRequestFullGameInfo();
        message.matchid =
            object.matchid !== undefined && object.matchid !== null
                ? Long.fromValue(object.matchid)
                : Long.UZERO;
        message.outcomeid =
            object.outcomeid !== undefined && object.outcomeid !== null
                ? Long.fromValue(object.outcomeid)
                : Long.UZERO;
        message.token = (_a = object.token) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCDataGCCStrike15V2MatchInfo() {
    return {
        matchid: Long.UZERO,
        matchtime: 0,
        watchablematchinfo: undefined,
        roundstatsLegacy: undefined,
        roundstatsall: []
    };
}
exports.CDataGCCStrike15V2MatchInfo = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.matchid.isZero()) {
            writer.uint32(8).uint64(message.matchid);
        }
        if (message.matchtime !== 0) {
            writer.uint32(16).uint32(message.matchtime);
        }
        if (message.watchablematchinfo !== undefined) {
            exports.WatchableMatchInfo.encode(message.watchablematchinfo, writer.uint32(26).fork()).ldelim();
        }
        if (message.roundstatsLegacy !== undefined) {
            exports.CMsgGCCStrike15V2MatchmakingServerRoundStats.encode(message.roundstatsLegacy, writer.uint32(34).fork()).ldelim();
        }
        for (const v of message.roundstatsall) {
            exports.CMsgGCCStrike15V2MatchmakingServerRoundStats.encode(v, writer.uint32(42).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCDataGCCStrike15V2MatchInfo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.matchid = reader.uint64();
                    break;
                case 2:
                    message.matchtime = reader.uint32();
                    break;
                case 3:
                    message.watchablematchinfo = exports.WatchableMatchInfo.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.roundstatsLegacy =
                        exports.CMsgGCCStrike15V2MatchmakingServerRoundStats.decode(reader, reader.uint32());
                    break;
                case 5:
                    message.roundstatsall.push(exports.CMsgGCCStrike15V2MatchmakingServerRoundStats.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCDataGCCStrike15V2MatchInfo();
        message.matchid =
            object.matchid !== undefined && object.matchid !== null
                ? Long.fromValue(object.matchid)
                : Long.UZERO;
        message.matchtime = (_a = object.matchtime) !== null && _a !== void 0 ? _a : 0;
        message.watchablematchinfo =
            object.watchablematchinfo !== undefined &&
                object.watchablematchinfo !== null
                ? exports.WatchableMatchInfo.fromPartial(object.watchablematchinfo)
                : undefined;
        message.roundstatsLegacy =
            object.roundstatsLegacy !== undefined && object.roundstatsLegacy !== null
                ? exports.CMsgGCCStrike15V2MatchmakingServerRoundStats.fromPartial(object.roundstatsLegacy)
                : undefined;
        message.roundstatsall =
            ((_b = object.roundstatsall) === null || _b === void 0 ? void 0 : _b.map(e => exports.CMsgGCCStrike15V2MatchmakingServerRoundStats.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCDataGCCStrike15V2TournamentGroupTeam() {
    return { teamId: 0, score: 0, correctpick: false };
}
exports.CDataGCCStrike15V2TournamentGroupTeam = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.teamId !== 0) {
            writer.uint32(8).int32(message.teamId);
        }
        if (message.score !== 0) {
            writer.uint32(16).int32(message.score);
        }
        if (message.correctpick === true) {
            writer.uint32(24).bool(message.correctpick);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCDataGCCStrike15V2TournamentGroupTeam();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.teamId = reader.int32();
                    break;
                case 2:
                    message.score = reader.int32();
                    break;
                case 3:
                    message.correctpick = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCDataGCCStrike15V2TournamentGroupTeam();
        message.teamId = (_a = object.teamId) !== null && _a !== void 0 ? _a : 0;
        message.score = (_b = object.score) !== null && _b !== void 0 ? _b : 0;
        message.correctpick = (_c = object.correctpick) !== null && _c !== void 0 ? _c : false;
        return message;
    }
};
function createBaseCDataGCCStrike15V2TournamentGroup() {
    return {
        groupid: 0,
        name: "",
        desc: "",
        picksDeprecated: 0,
        teams: [],
        stageIds: [],
        picklockuntiltime: 0,
        pickableteams: 0,
        pointsPerPick: 0,
        picks: []
    };
}
exports.CDataGCCStrike15V2TournamentGroup = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.groupid !== 0) {
            writer.uint32(8).uint32(message.groupid);
        }
        if (message.name !== "") {
            writer.uint32(18).string(message.name);
        }
        if (message.desc !== "") {
            writer.uint32(26).string(message.desc);
        }
        if (message.picksDeprecated !== 0) {
            writer.uint32(32).uint32(message.picksDeprecated);
        }
        for (const v of message.teams) {
            exports.CDataGCCStrike15V2TournamentGroupTeam.encode(v, writer.uint32(42).fork()).ldelim();
        }
        writer.uint32(50).fork();
        for (const v of message.stageIds) {
            writer.int32(v);
        }
        writer.ldelim();
        if (message.picklockuntiltime !== 0) {
            writer.uint32(56).uint32(message.picklockuntiltime);
        }
        if (message.pickableteams !== 0) {
            writer.uint32(64).uint32(message.pickableteams);
        }
        if (message.pointsPerPick !== 0) {
            writer.uint32(72).uint32(message.pointsPerPick);
        }
        for (const v of message.picks) {
            exports.CDataGCCStrike15V2TournamentGroup_Picks.encode(v, writer.uint32(82).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCDataGCCStrike15V2TournamentGroup();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.groupid = reader.uint32();
                    break;
                case 2:
                    message.name = reader.string();
                    break;
                case 3:
                    message.desc = reader.string();
                    break;
                case 4:
                    message.picksDeprecated = reader.uint32();
                    break;
                case 5:
                    message.teams.push(exports.CDataGCCStrike15V2TournamentGroupTeam.decode(reader, reader.uint32()));
                    break;
                case 6:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.stageIds.push(reader.int32());
                        }
                    }
                    else {
                        message.stageIds.push(reader.int32());
                    }
                    break;
                case 7:
                    message.picklockuntiltime = reader.uint32();
                    break;
                case 8:
                    message.pickableteams = reader.uint32();
                    break;
                case 9:
                    message.pointsPerPick = reader.uint32();
                    break;
                case 10:
                    message.picks.push(exports.CDataGCCStrike15V2TournamentGroup_Picks.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
        const message = createBaseCDataGCCStrike15V2TournamentGroup();
        message.groupid = (_a = object.groupid) !== null && _a !== void 0 ? _a : 0;
        message.name = (_b = object.name) !== null && _b !== void 0 ? _b : "";
        message.desc = (_c = object.desc) !== null && _c !== void 0 ? _c : "";
        message.picksDeprecated = (_d = object.picksDeprecated) !== null && _d !== void 0 ? _d : 0;
        message.teams =
            ((_e = object.teams) === null || _e === void 0 ? void 0 : _e.map(e => exports.CDataGCCStrike15V2TournamentGroupTeam.fromPartial(e))) || [];
        message.stageIds = ((_f = object.stageIds) === null || _f === void 0 ? void 0 : _f.map(e => e)) || [];
        message.picklockuntiltime = (_g = object.picklockuntiltime) !== null && _g !== void 0 ? _g : 0;
        message.pickableteams = (_h = object.pickableteams) !== null && _h !== void 0 ? _h : 0;
        message.pointsPerPick = (_j = object.pointsPerPick) !== null && _j !== void 0 ? _j : 0;
        message.picks =
            ((_k = object.picks) === null || _k === void 0 ? void 0 : _k.map(e => exports.CDataGCCStrike15V2TournamentGroup_Picks.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCDataGCCStrike15V2TournamentGroup_Picks() {
    return { pickids: [] };
}
exports.CDataGCCStrike15V2TournamentGroup_Picks = {
    encode(message, writer = minimal_1.Writer.create()) {
        writer.uint32(10).fork();
        for (const v of message.pickids) {
            writer.int32(v);
        }
        writer.ldelim();
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCDataGCCStrike15V2TournamentGroup_Picks();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.pickids.push(reader.int32());
                        }
                    }
                    else {
                        message.pickids.push(reader.int32());
                    }
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCDataGCCStrike15V2TournamentGroup_Picks();
        message.pickids = ((_a = object.pickids) === null || _a === void 0 ? void 0 : _a.map(e => e)) || [];
        return message;
    }
};
function createBaseCDataGCCStrike15V2TournamentSection() {
    return { sectionid: 0, name: "", desc: "", groups: [] };
}
exports.CDataGCCStrike15V2TournamentSection = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.sectionid !== 0) {
            writer.uint32(8).uint32(message.sectionid);
        }
        if (message.name !== "") {
            writer.uint32(18).string(message.name);
        }
        if (message.desc !== "") {
            writer.uint32(26).string(message.desc);
        }
        for (const v of message.groups) {
            exports.CDataGCCStrike15V2TournamentGroup.encode(v, writer.uint32(34).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCDataGCCStrike15V2TournamentSection();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.sectionid = reader.uint32();
                    break;
                case 2:
                    message.name = reader.string();
                    break;
                case 3:
                    message.desc = reader.string();
                    break;
                case 4:
                    message.groups.push(exports.CDataGCCStrike15V2TournamentGroup.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCDataGCCStrike15V2TournamentSection();
        message.sectionid = (_a = object.sectionid) !== null && _a !== void 0 ? _a : 0;
        message.name = (_b = object.name) !== null && _b !== void 0 ? _b : "";
        message.desc = (_c = object.desc) !== null && _c !== void 0 ? _c : "";
        message.groups =
            ((_d = object.groups) === null || _d === void 0 ? void 0 : _d.map(e => exports.CDataGCCStrike15V2TournamentGroup.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCDataGCCStrike15V2TournamentInfo() {
    return { sections: [], tournamentEvent: undefined, tournamentTeams: [] };
}
exports.CDataGCCStrike15V2TournamentInfo = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.sections) {
            exports.CDataGCCStrike15V2TournamentSection.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.tournamentEvent !== undefined) {
            exports.TournamentEvent.encode(message.tournamentEvent, writer.uint32(18).fork()).ldelim();
        }
        for (const v of message.tournamentTeams) {
            exports.TournamentTeam.encode(v, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCDataGCCStrike15V2TournamentInfo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.sections.push(exports.CDataGCCStrike15V2TournamentSection.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.tournamentEvent = exports.TournamentEvent.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.tournamentTeams.push(exports.TournamentTeam.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCDataGCCStrike15V2TournamentInfo();
        message.sections =
            ((_a = object.sections) === null || _a === void 0 ? void 0 : _a.map(e => exports.CDataGCCStrike15V2TournamentSection.fromPartial(e))) || [];
        message.tournamentEvent =
            object.tournamentEvent !== undefined && object.tournamentEvent !== null
                ? exports.TournamentEvent.fromPartial(object.tournamentEvent)
                : undefined;
        message.tournamentTeams =
            ((_b = object.tournamentTeams) === null || _b === void 0 ? void 0 : _b.map(e => exports.TournamentTeam.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchList() {
    return {
        msgrequestid: 0,
        accountid: 0,
        servertime: 0,
        matches: [],
        streams: [],
        tournamentinfo: undefined
    };
}
exports.CMsgGCCStrike15V2MatchList = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.msgrequestid !== 0) {
            writer.uint32(8).uint32(message.msgrequestid);
        }
        if (message.accountid !== 0) {
            writer.uint32(16).uint32(message.accountid);
        }
        if (message.servertime !== 0) {
            writer.uint32(24).uint32(message.servertime);
        }
        for (const v of message.matches) {
            exports.CDataGCCStrike15V2MatchInfo.encode(v, writer.uint32(34).fork()).ldelim();
        }
        for (const v of message.streams) {
            exports.TournamentTeam.encode(v, writer.uint32(42).fork()).ldelim();
        }
        if (message.tournamentinfo !== undefined) {
            exports.CDataGCCStrike15V2TournamentInfo.encode(message.tournamentinfo, writer.uint32(50).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchList();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.msgrequestid = reader.uint32();
                    break;
                case 2:
                    message.accountid = reader.uint32();
                    break;
                case 3:
                    message.servertime = reader.uint32();
                    break;
                case 4:
                    message.matches.push(exports.CDataGCCStrike15V2MatchInfo.decode(reader, reader.uint32()));
                    break;
                case 5:
                    message.streams.push(exports.TournamentTeam.decode(reader, reader.uint32()));
                    break;
                case 6:
                    message.tournamentinfo = exports.CDataGCCStrike15V2TournamentInfo.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseCMsgGCCStrike15V2MatchList();
        message.msgrequestid = (_a = object.msgrequestid) !== null && _a !== void 0 ? _a : 0;
        message.accountid = (_b = object.accountid) !== null && _b !== void 0 ? _b : 0;
        message.servertime = (_c = object.servertime) !== null && _c !== void 0 ? _c : 0;
        message.matches =
            ((_d = object.matches) === null || _d === void 0 ? void 0 : _d.map(e => exports.CDataGCCStrike15V2MatchInfo.fromPartial(e))) ||
                [];
        message.streams =
            ((_e = object.streams) === null || _e === void 0 ? void 0 : _e.map(e => exports.TournamentTeam.fromPartial(e))) || [];
        message.tournamentinfo =
            object.tournamentinfo !== undefined && object.tournamentinfo !== null
                ? exports.CDataGCCStrike15V2TournamentInfo.fromPartial(object.tournamentinfo)
                : undefined;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2MatchListTournamentOperatorMgmt() {
    return { eventid: 0, matches: [] };
}
exports.CMsgGCCStrike15V2MatchListTournamentOperatorMgmt = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.eventid !== 0) {
            writer.uint32(8).int32(message.eventid);
        }
        for (const v of message.matches) {
            exports.CDataGCCStrike15V2MatchInfo.encode(v, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2MatchListTournamentOperatorMgmt();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.eventid = reader.int32();
                    break;
                case 2:
                    message.matches.push(exports.CDataGCCStrike15V2MatchInfo.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2MatchListTournamentOperatorMgmt();
        message.eventid = (_a = object.eventid) !== null && _a !== void 0 ? _a : 0;
        message.matches =
            ((_b = object.matches) === null || _b === void 0 ? void 0 : _b.map(e => exports.CDataGCCStrike15V2MatchInfo.fromPartial(e))) ||
                [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2Predictions() {
    return { eventId: 0, groupMatchTeamPicks: [] };
}
exports.CMsgGCCStrike15V2Predictions = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.eventId !== 0) {
            writer.uint32(8).uint32(message.eventId);
        }
        for (const v of message.groupMatchTeamPicks) {
            exports.CMsgGCCStrike15V2Predictions_GroupMatchTeamPick.encode(v, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2Predictions();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.eventId = reader.uint32();
                    break;
                case 2:
                    message.groupMatchTeamPicks.push(exports.CMsgGCCStrike15V2Predictions_GroupMatchTeamPick.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2Predictions();
        message.eventId = (_a = object.eventId) !== null && _a !== void 0 ? _a : 0;
        message.groupMatchTeamPicks =
            ((_b = object.groupMatchTeamPicks) === null || _b === void 0 ? void 0 : _b.map(e => exports.CMsgGCCStrike15V2Predictions_GroupMatchTeamPick.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2Predictions_GroupMatchTeamPick() {
    return { sectionid: 0, groupid: 0, index: 0, teamid: 0, itemid: Long.UZERO };
}
exports.CMsgGCCStrike15V2Predictions_GroupMatchTeamPick = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.sectionid !== 0) {
            writer.uint32(8).int32(message.sectionid);
        }
        if (message.groupid !== 0) {
            writer.uint32(16).int32(message.groupid);
        }
        if (message.index !== 0) {
            writer.uint32(24).int32(message.index);
        }
        if (message.teamid !== 0) {
            writer.uint32(32).int32(message.teamid);
        }
        if (!message.itemid.isZero()) {
            writer.uint32(40).uint64(message.itemid);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2Predictions_GroupMatchTeamPick();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.sectionid = reader.int32();
                    break;
                case 2:
                    message.groupid = reader.int32();
                    break;
                case 3:
                    message.index = reader.int32();
                    break;
                case 4:
                    message.teamid = reader.int32();
                    break;
                case 5:
                    message.itemid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCMsgGCCStrike15V2Predictions_GroupMatchTeamPick();
        message.sectionid = (_a = object.sectionid) !== null && _a !== void 0 ? _a : 0;
        message.groupid = (_b = object.groupid) !== null && _b !== void 0 ? _b : 0;
        message.index = (_c = object.index) !== null && _c !== void 0 ? _c : 0;
        message.teamid = (_d = object.teamid) !== null && _d !== void 0 ? _d : 0;
        message.itemid =
            object.itemid !== undefined && object.itemid !== null
                ? Long.fromValue(object.itemid)
                : Long.UZERO;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2Fantasy() {
    return { eventId: 0, teams: [] };
}
exports.CMsgGCCStrike15V2Fantasy = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.eventId !== 0) {
            writer.uint32(8).uint32(message.eventId);
        }
        for (const v of message.teams) {
            exports.CMsgGCCStrike15V2Fantasy_FantasyTeam.encode(v, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2Fantasy();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.eventId = reader.uint32();
                    break;
                case 2:
                    message.teams.push(exports.CMsgGCCStrike15V2Fantasy_FantasyTeam.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2Fantasy();
        message.eventId = (_a = object.eventId) !== null && _a !== void 0 ? _a : 0;
        message.teams =
            ((_b = object.teams) === null || _b === void 0 ? void 0 : _b.map(e => exports.CMsgGCCStrike15V2Fantasy_FantasyTeam.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2Fantasy_FantasySlot() {
    return { type: 0, pick: 0, itemid: Long.UZERO };
}
exports.CMsgGCCStrike15V2Fantasy_FantasySlot = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.type !== 0) {
            writer.uint32(8).int32(message.type);
        }
        if (message.pick !== 0) {
            writer.uint32(16).int32(message.pick);
        }
        if (!message.itemid.isZero()) {
            writer.uint32(24).uint64(message.itemid);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2Fantasy_FantasySlot();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.type = reader.int32();
                    break;
                case 2:
                    message.pick = reader.int32();
                    break;
                case 3:
                    message.itemid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2Fantasy_FantasySlot();
        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;
        message.pick = (_b = object.pick) !== null && _b !== void 0 ? _b : 0;
        message.itemid =
            object.itemid !== undefined && object.itemid !== null
                ? Long.fromValue(object.itemid)
                : Long.UZERO;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2Fantasy_FantasyTeam() {
    return { sectionid: 0, slots: [] };
}
exports.CMsgGCCStrike15V2Fantasy_FantasyTeam = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.sectionid !== 0) {
            writer.uint32(8).int32(message.sectionid);
        }
        for (const v of message.slots) {
            exports.CMsgGCCStrike15V2Fantasy_FantasySlot.encode(v, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2Fantasy_FantasyTeam();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.sectionid = reader.int32();
                    break;
                case 2:
                    message.slots.push(exports.CMsgGCCStrike15V2Fantasy_FantasySlot.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2Fantasy_FantasyTeam();
        message.sectionid = (_a = object.sectionid) !== null && _a !== void 0 ? _a : 0;
        message.slots =
            ((_b = object.slots) === null || _b === void 0 ? void 0 : _b.map(e => exports.CMsgGCCStrike15V2Fantasy_FantasySlot.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCAttributeString() {
    return { value: "" };
}
exports.CAttributeString = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.value !== "") {
            writer.uint32(10).string(message.value);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCAttributeString();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.value = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCAttributeString();
        message.value = (_a = object.value) !== null && _a !== void 0 ? _a : "";
        return message;
    }
};
function createBaseCMsgCStrike15Welcome() {
    return {
        storeItemHash: 0,
        timeplayedconsecutively: 0,
        timeFirstPlayed: 0,
        lastTimePlayed: 0,
        lastIpAddress: 0,
        gscookieid: Long.UZERO,
        uniqueid: Long.UZERO
    };
}
exports.CMsgCStrike15Welcome = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.storeItemHash !== 0) {
            writer.uint32(40).uint32(message.storeItemHash);
        }
        if (message.timeplayedconsecutively !== 0) {
            writer.uint32(48).uint32(message.timeplayedconsecutively);
        }
        if (message.timeFirstPlayed !== 0) {
            writer.uint32(80).uint32(message.timeFirstPlayed);
        }
        if (message.lastTimePlayed !== 0) {
            writer.uint32(96).uint32(message.lastTimePlayed);
        }
        if (message.lastIpAddress !== 0) {
            writer.uint32(104).uint32(message.lastIpAddress);
        }
        if (!message.gscookieid.isZero()) {
            writer.uint32(144).uint64(message.gscookieid);
        }
        if (!message.uniqueid.isZero()) {
            writer.uint32(152).uint64(message.uniqueid);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgCStrike15Welcome();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 5:
                    message.storeItemHash = reader.uint32();
                    break;
                case 6:
                    message.timeplayedconsecutively = reader.uint32();
                    break;
                case 10:
                    message.timeFirstPlayed = reader.uint32();
                    break;
                case 12:
                    message.lastTimePlayed = reader.uint32();
                    break;
                case 13:
                    message.lastIpAddress = reader.uint32();
                    break;
                case 18:
                    message.gscookieid = reader.uint64();
                    break;
                case 19:
                    message.uniqueid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseCMsgCStrike15Welcome();
        message.storeItemHash = (_a = object.storeItemHash) !== null && _a !== void 0 ? _a : 0;
        message.timeplayedconsecutively = (_b = object.timeplayedconsecutively) !== null && _b !== void 0 ? _b : 0;
        message.timeFirstPlayed = (_c = object.timeFirstPlayed) !== null && _c !== void 0 ? _c : 0;
        message.lastTimePlayed = (_d = object.lastTimePlayed) !== null && _d !== void 0 ? _d : 0;
        message.lastIpAddress = (_e = object.lastIpAddress) !== null && _e !== void 0 ? _e : 0;
        message.gscookieid =
            object.gscookieid !== undefined && object.gscookieid !== null
                ? Long.fromValue(object.gscookieid)
                : Long.UZERO;
        message.uniqueid =
            object.uniqueid !== undefined && object.uniqueid !== null
                ? Long.fromValue(object.uniqueid)
                : Long.UZERO;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientVarValueNotificationInfo() {
    return {
        valueName: "",
        valueInt: 0,
        serverAddr: 0,
        serverPort: 0,
        chokedBlocks: []
    };
}
exports.CMsgGCCStrike15V2ClientVarValueNotificationInfo = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.valueName !== "") {
            writer.uint32(10).string(message.valueName);
        }
        if (message.valueInt !== 0) {
            writer.uint32(16).int32(message.valueInt);
        }
        if (message.serverAddr !== 0) {
            writer.uint32(24).uint32(message.serverAddr);
        }
        if (message.serverPort !== 0) {
            writer.uint32(32).uint32(message.serverPort);
        }
        for (const v of message.chokedBlocks) {
            writer.uint32(42).string(v);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientVarValueNotificationInfo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.valueName = reader.string();
                    break;
                case 2:
                    message.valueInt = reader.int32();
                    break;
                case 3:
                    message.serverAddr = reader.uint32();
                    break;
                case 4:
                    message.serverPort = reader.uint32();
                    break;
                case 5:
                    message.chokedBlocks.push(reader.string());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseCMsgGCCStrike15V2ClientVarValueNotificationInfo();
        message.valueName = (_a = object.valueName) !== null && _a !== void 0 ? _a : "";
        message.valueInt = (_b = object.valueInt) !== null && _b !== void 0 ? _b : 0;
        message.serverAddr = (_c = object.serverAddr) !== null && _c !== void 0 ? _c : 0;
        message.serverPort = (_d = object.serverPort) !== null && _d !== void 0 ? _d : 0;
        message.chokedBlocks = ((_e = object.chokedBlocks) === null || _e === void 0 ? void 0 : _e.map(e => e)) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ServerVarValueNotificationInfo() {
    return { accountid: 0, viewangles: [], type: 0, userdata: [] };
}
exports.CMsgGCCStrike15V2ServerVarValueNotificationInfo = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountid !== 0) {
            writer.uint32(8).uint32(message.accountid);
        }
        writer.uint32(18).fork();
        for (const v of message.viewangles) {
            writer.uint32(v);
        }
        writer.ldelim();
        if (message.type !== 0) {
            writer.uint32(24).uint32(message.type);
        }
        writer.uint32(34).fork();
        for (const v of message.userdata) {
            writer.uint32(v);
        }
        writer.ldelim();
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ServerVarValueNotificationInfo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountid = reader.uint32();
                    break;
                case 2:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.viewangles.push(reader.uint32());
                        }
                    }
                    else {
                        message.viewangles.push(reader.uint32());
                    }
                    break;
                case 3:
                    message.type = reader.uint32();
                    break;
                case 4:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.userdata.push(reader.uint32());
                        }
                    }
                    else {
                        message.userdata.push(reader.uint32());
                    }
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCMsgGCCStrike15V2ServerVarValueNotificationInfo();
        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;
        message.viewangles = ((_b = object.viewangles) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];
        message.type = (_c = object.type) !== null && _c !== void 0 ? _c : 0;
        message.userdata = ((_d = object.userdata) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2GiftsLeaderboardRequest() {
    return {};
}
exports.CMsgGCCStrike15V2GiftsLeaderboardRequest = {
    encode(_, writer = minimal_1.Writer.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2GiftsLeaderboardRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseCMsgGCCStrike15V2GiftsLeaderboardRequest();
        return message;
    }
};
function createBaseCMsgGCCStrike15V2GiftsLeaderboardResponse() {
    return {
        servertime: 0,
        timePeriodSeconds: 0,
        totalGiftsGiven: 0,
        totalGivers: 0,
        entries: []
    };
}
exports.CMsgGCCStrike15V2GiftsLeaderboardResponse = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.servertime !== 0) {
            writer.uint32(8).uint32(message.servertime);
        }
        if (message.timePeriodSeconds !== 0) {
            writer.uint32(16).uint32(message.timePeriodSeconds);
        }
        if (message.totalGiftsGiven !== 0) {
            writer.uint32(24).uint32(message.totalGiftsGiven);
        }
        if (message.totalGivers !== 0) {
            writer.uint32(32).uint32(message.totalGivers);
        }
        for (const v of message.entries) {
            exports.CMsgGCCStrike15V2GiftsLeaderboardResponse_GiftLeaderboardEntry.encode(v, writer.uint32(42).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2GiftsLeaderboardResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.servertime = reader.uint32();
                    break;
                case 2:
                    message.timePeriodSeconds = reader.uint32();
                    break;
                case 3:
                    message.totalGiftsGiven = reader.uint32();
                    break;
                case 4:
                    message.totalGivers = reader.uint32();
                    break;
                case 5:
                    message.entries.push(exports.CMsgGCCStrike15V2GiftsLeaderboardResponse_GiftLeaderboardEntry.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseCMsgGCCStrike15V2GiftsLeaderboardResponse();
        message.servertime = (_a = object.servertime) !== null && _a !== void 0 ? _a : 0;
        message.timePeriodSeconds = (_b = object.timePeriodSeconds) !== null && _b !== void 0 ? _b : 0;
        message.totalGiftsGiven = (_c = object.totalGiftsGiven) !== null && _c !== void 0 ? _c : 0;
        message.totalGivers = (_d = object.totalGivers) !== null && _d !== void 0 ? _d : 0;
        message.entries =
            ((_e = object.entries) === null || _e === void 0 ? void 0 : _e.map(e => exports.CMsgGCCStrike15V2GiftsLeaderboardResponse_GiftLeaderboardEntry.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2GiftsLeaderboardResponse_GiftLeaderboardEntry() {
    return { accountid: 0, gifts: 0 };
}
exports.CMsgGCCStrike15V2GiftsLeaderboardResponse_GiftLeaderboardEntry = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountid !== 0) {
            writer.uint32(8).uint32(message.accountid);
        }
        if (message.gifts !== 0) {
            writer.uint32(16).uint32(message.gifts);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2GiftsLeaderboardResponse_GiftLeaderboardEntry();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountid = reader.uint32();
                    break;
                case 2:
                    message.gifts = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2GiftsLeaderboardResponse_GiftLeaderboardEntry();
        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;
        message.gifts = (_b = object.gifts) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientSubmitSurveyVote() {
    return { surveyId: 0, vote: 0 };
}
exports.CMsgGCCStrike15V2ClientSubmitSurveyVote = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.surveyId !== 0) {
            writer.uint32(8).uint32(message.surveyId);
        }
        if (message.vote !== 0) {
            writer.uint32(16).uint32(message.vote);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientSubmitSurveyVote();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.surveyId = reader.uint32();
                    break;
                case 2:
                    message.vote = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2ClientSubmitSurveyVote();
        message.surveyId = (_a = object.surveyId) !== null && _a !== void 0 ? _a : 0;
        message.vote = (_b = object.vote) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2Server2GCClientValidate() {
    return { accountid: 0 };
}
exports.CMsgGCCStrike15V2Server2GCClientValidate = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountid !== 0) {
            writer.uint32(8).uint32(message.accountid);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2Server2GCClientValidate();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountid = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2Server2GCClientValidate();
        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2GC2ClientTournamentInfo() {
    return { eventid: 0, stageid: 0, gameType: 0, teamids: [] };
}
exports.CMsgGCCStrike15V2GC2ClientTournamentInfo = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.eventid !== 0) {
            writer.uint32(8).uint32(message.eventid);
        }
        if (message.stageid !== 0) {
            writer.uint32(16).uint32(message.stageid);
        }
        if (message.gameType !== 0) {
            writer.uint32(24).uint32(message.gameType);
        }
        writer.uint32(34).fork();
        for (const v of message.teamids) {
            writer.uint32(v);
        }
        writer.ldelim();
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2GC2ClientTournamentInfo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.eventid = reader.uint32();
                    break;
                case 2:
                    message.stageid = reader.uint32();
                    break;
                case 3:
                    message.gameType = reader.uint32();
                    break;
                case 4:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.teamids.push(reader.uint32());
                        }
                    }
                    else {
                        message.teamids.push(reader.uint32());
                    }
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCMsgGCCStrike15V2GC2ClientTournamentInfo();
        message.eventid = (_a = object.eventid) !== null && _a !== void 0 ? _a : 0;
        message.stageid = (_b = object.stageid) !== null && _b !== void 0 ? _b : 0;
        message.gameType = (_c = object.gameType) !== null && _c !== void 0 ? _c : 0;
        message.teamids = ((_d = object.teamids) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];
        return message;
    }
};
function createBaseCSOEconCoupon() {
    return { entryid: 0, defidx: 0, expirationDate: 0 };
}
exports.CSOEconCoupon = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.entryid !== 0) {
            writer.uint32(8).uint32(message.entryid);
        }
        if (message.defidx !== 0) {
            writer.uint32(16).uint32(message.defidx);
        }
        if (message.expirationDate !== 0) {
            writer.uint32(29).fixed32(message.expirationDate);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSOEconCoupon();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.entryid = reader.uint32();
                    break;
                case 2:
                    message.defidx = reader.uint32();
                    break;
                case 3:
                    message.expirationDate = reader.fixed32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCSOEconCoupon();
        message.entryid = (_a = object.entryid) !== null && _a !== void 0 ? _a : 0;
        message.defidx = (_b = object.defidx) !== null && _b !== void 0 ? _b : 0;
        message.expirationDate = (_c = object.expirationDate) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseCSOQuestProgress() {
    return { questid: 0, pointsRemaining: 0, bonusPoints: 0 };
}
exports.CSOQuestProgress = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.questid !== 0) {
            writer.uint32(8).uint32(message.questid);
        }
        if (message.pointsRemaining !== 0) {
            writer.uint32(16).uint32(message.pointsRemaining);
        }
        if (message.bonusPoints !== 0) {
            writer.uint32(24).uint32(message.bonusPoints);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSOQuestProgress();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.questid = reader.uint32();
                    break;
                case 2:
                    message.pointsRemaining = reader.uint32();
                    break;
                case 3:
                    message.bonusPoints = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCSOQuestProgress();
        message.questid = (_a = object.questid) !== null && _a !== void 0 ? _a : 0;
        message.pointsRemaining = (_b = object.pointsRemaining) !== null && _b !== void 0 ? _b : 0;
        message.bonusPoints = (_c = object.bonusPoints) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseCSOAccountSeasonalOperation() {
    return {
        seasonValue: 0,
        tierUnlocked: 0,
        premiumTiers: 0,
        missionId: 0,
        missionsCompleted: 0,
        redeemableBalance: 0,
        seasonPassTime: 0
    };
}
exports.CSOAccountSeasonalOperation = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.seasonValue !== 0) {
            writer.uint32(8).uint32(message.seasonValue);
        }
        if (message.tierUnlocked !== 0) {
            writer.uint32(16).uint32(message.tierUnlocked);
        }
        if (message.premiumTiers !== 0) {
            writer.uint32(24).uint32(message.premiumTiers);
        }
        if (message.missionId !== 0) {
            writer.uint32(32).uint32(message.missionId);
        }
        if (message.missionsCompleted !== 0) {
            writer.uint32(40).uint32(message.missionsCompleted);
        }
        if (message.redeemableBalance !== 0) {
            writer.uint32(48).uint32(message.redeemableBalance);
        }
        if (message.seasonPassTime !== 0) {
            writer.uint32(56).uint32(message.seasonPassTime);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSOAccountSeasonalOperation();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.seasonValue = reader.uint32();
                    break;
                case 2:
                    message.tierUnlocked = reader.uint32();
                    break;
                case 3:
                    message.premiumTiers = reader.uint32();
                    break;
                case 4:
                    message.missionId = reader.uint32();
                    break;
                case 5:
                    message.missionsCompleted = reader.uint32();
                    break;
                case 6:
                    message.redeemableBalance = reader.uint32();
                    break;
                case 7:
                    message.seasonPassTime = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g;
        const message = createBaseCSOAccountSeasonalOperation();
        message.seasonValue = (_a = object.seasonValue) !== null && _a !== void 0 ? _a : 0;
        message.tierUnlocked = (_b = object.tierUnlocked) !== null && _b !== void 0 ? _b : 0;
        message.premiumTiers = (_c = object.premiumTiers) !== null && _c !== void 0 ? _c : 0;
        message.missionId = (_d = object.missionId) !== null && _d !== void 0 ? _d : 0;
        message.missionsCompleted = (_e = object.missionsCompleted) !== null && _e !== void 0 ? _e : 0;
        message.redeemableBalance = (_f = object.redeemableBalance) !== null && _f !== void 0 ? _f : 0;
        message.seasonPassTime = (_g = object.seasonPassTime) !== null && _g !== void 0 ? _g : 0;
        return message;
    }
};
function createBaseCSOAccountRecurringSubscription() {
    return { timeNextCycle: 0, timeInitiated: 0 };
}
exports.CSOAccountRecurringSubscription = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.timeNextCycle !== 0) {
            writer.uint32(8).uint32(message.timeNextCycle);
        }
        if (message.timeInitiated !== 0) {
            writer.uint32(16).uint32(message.timeInitiated);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSOAccountRecurringSubscription();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.timeNextCycle = reader.uint32();
                    break;
                case 2:
                    message.timeInitiated = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCSOAccountRecurringSubscription();
        message.timeNextCycle = (_a = object.timeNextCycle) !== null && _a !== void 0 ? _a : 0;
        message.timeInitiated = (_b = object.timeInitiated) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCSOPersonaDataPublic() {
    return { playerLevel: 0, commendation: undefined, elevatedState: false };
}
exports.CSOPersonaDataPublic = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.playerLevel !== 0) {
            writer.uint32(8).int32(message.playerLevel);
        }
        if (message.commendation !== undefined) {
            exports.PlayerCommendationInfo.encode(message.commendation, writer.uint32(18).fork()).ldelim();
        }
        if (message.elevatedState === true) {
            writer.uint32(24).bool(message.elevatedState);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSOPersonaDataPublic();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.playerLevel = reader.int32();
                    break;
                case 2:
                    message.commendation = exports.PlayerCommendationInfo.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.elevatedState = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCSOPersonaDataPublic();
        message.playerLevel = (_a = object.playerLevel) !== null && _a !== void 0 ? _a : 0;
        message.commendation =
            object.commendation !== undefined && object.commendation !== null
                ? exports.PlayerCommendationInfo.fromPartial(object.commendation)
                : undefined;
        message.elevatedState = (_b = object.elevatedState) !== null && _b !== void 0 ? _b : false;
        return message;
    }
};
function createBaseCMsgGCGlobalGameSubscribe() {
    return { ticket: Long.UZERO };
}
exports.CMsgGCGlobalGameSubscribe = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.ticket.isZero()) {
            writer.uint32(8).uint64(message.ticket);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCGlobalGameSubscribe();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.ticket = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCMsgGCGlobalGameSubscribe();
        message.ticket =
            object.ticket !== undefined && object.ticket !== null
                ? Long.fromValue(object.ticket)
                : Long.UZERO;
        return message;
    }
};
function createBaseCMsgGCGlobalGameUnsubscribe() {
    return { timeleft: 0 };
}
exports.CMsgGCGlobalGameUnsubscribe = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.timeleft !== 0) {
            writer.uint32(8).int32(message.timeleft);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCGlobalGameUnsubscribe();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.timeleft = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCGlobalGameUnsubscribe();
        message.timeleft = (_a = object.timeleft) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCMsgGCGlobalGamePlay() {
    return { ticket: Long.UZERO, gametimems: 0, msperpoint: 0 };
}
exports.CMsgGCGlobalGamePlay = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.ticket.isZero()) {
            writer.uint32(8).uint64(message.ticket);
        }
        if (message.gametimems !== 0) {
            writer.uint32(16).uint32(message.gametimems);
        }
        if (message.msperpoint !== 0) {
            writer.uint32(24).uint32(message.msperpoint);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCGlobalGamePlay();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.ticket = reader.uint64();
                    break;
                case 2:
                    message.gametimems = reader.uint32();
                    break;
                case 3:
                    message.msperpoint = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCGlobalGamePlay();
        message.ticket =
            object.ticket !== undefined && object.ticket !== null
                ? Long.fromValue(object.ticket)
                : Long.UZERO;
        message.gametimems = (_a = object.gametimems) !== null && _a !== void 0 ? _a : 0;
        message.msperpoint = (_b = object.msperpoint) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2AcknowledgePenalty() {
    return { acknowledged: 0 };
}
exports.CMsgGCCStrike15V2AcknowledgePenalty = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.acknowledged !== 0) {
            writer.uint32(8).int32(message.acknowledged);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2AcknowledgePenalty();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.acknowledged = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2AcknowledgePenalty();
        message.acknowledged = (_a = object.acknowledged) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2Client2GCRequestPrestigeCoin() {
    return { defindex: 0, upgradeid: Long.UZERO, hours: 0, prestigetime: 0 };
}
exports.CMsgGCCStrike15V2Client2GCRequestPrestigeCoin = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.defindex !== 0) {
            writer.uint32(8).uint32(message.defindex);
        }
        if (!message.upgradeid.isZero()) {
            writer.uint32(16).uint64(message.upgradeid);
        }
        if (message.hours !== 0) {
            writer.uint32(24).uint32(message.hours);
        }
        if (message.prestigetime !== 0) {
            writer.uint32(32).uint32(message.prestigetime);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2Client2GCRequestPrestigeCoin();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.defindex = reader.uint32();
                    break;
                case 2:
                    message.upgradeid = reader.uint64();
                    break;
                case 3:
                    message.hours = reader.uint32();
                    break;
                case 4:
                    message.prestigetime = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCMsgGCCStrike15V2Client2GCRequestPrestigeCoin();
        message.defindex = (_a = object.defindex) !== null && _a !== void 0 ? _a : 0;
        message.upgradeid =
            object.upgradeid !== undefined && object.upgradeid !== null
                ? Long.fromValue(object.upgradeid)
                : Long.UZERO;
        message.hours = (_b = object.hours) !== null && _b !== void 0 ? _b : 0;
        message.prestigetime = (_c = object.prestigetime) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2Client2GCStreamUnlock() {
    return { ticket: Long.UZERO, os: 0 };
}
exports.CMsgGCCStrike15V2Client2GCStreamUnlock = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.ticket.isZero()) {
            writer.uint32(8).uint64(message.ticket);
        }
        if (message.os !== 0) {
            writer.uint32(16).int32(message.os);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2Client2GCStreamUnlock();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.ticket = reader.uint64();
                    break;
                case 2:
                    message.os = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2Client2GCStreamUnlock();
        message.ticket =
            object.ticket !== undefined && object.ticket !== null
                ? Long.fromValue(object.ticket)
                : Long.UZERO;
        message.os = (_a = object.os) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientToGCRequestElevate() {
    return { stage: 0 };
}
exports.CMsgGCCStrike15V2ClientToGCRequestElevate = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.stage !== 0) {
            writer.uint32(8).uint32(message.stage);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientToGCRequestElevate();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.stage = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2ClientToGCRequestElevate();
        message.stage = (_a = object.stage) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientToGCChat() {
    return { matchId: Long.UZERO, text: "" };
}
exports.CMsgGCCStrike15V2ClientToGCChat = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.matchId.isZero()) {
            writer.uint32(8).uint64(message.matchId);
        }
        if (message.text !== "") {
            writer.uint32(18).string(message.text);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientToGCChat();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.matchId = reader.uint64();
                    break;
                case 2:
                    message.text = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2ClientToGCChat();
        message.matchId =
            object.matchId !== undefined && object.matchId !== null
                ? Long.fromValue(object.matchId)
                : Long.UZERO;
        message.text = (_a = object.text) !== null && _a !== void 0 ? _a : "";
        return message;
    }
};
function createBaseCMsgGCCStrike15V2GCToClientChat() {
    return { accountId: 0, text: "" };
}
exports.CMsgGCCStrike15V2GCToClientChat = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountId !== 0) {
            writer.uint32(8).uint32(message.accountId);
        }
        if (message.text !== "") {
            writer.uint32(18).string(message.text);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2GCToClientChat();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountId = reader.uint32();
                    break;
                case 2:
                    message.text = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2GCToClientChat();
        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;
        message.text = (_b = object.text) !== null && _b !== void 0 ? _b : "";
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientAuthKeyCode() {
    return { eventid: 0, code: "" };
}
exports.CMsgGCCStrike15V2ClientAuthKeyCode = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.eventid !== 0) {
            writer.uint32(8).uint32(message.eventid);
        }
        if (message.code !== "") {
            writer.uint32(18).string(message.code);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientAuthKeyCode();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.eventid = reader.uint32();
                    break;
                case 2:
                    message.code = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2ClientAuthKeyCode();
        message.eventid = (_a = object.eventid) !== null && _a !== void 0 ? _a : 0;
        message.code = (_b = object.code) !== null && _b !== void 0 ? _b : "";
        return message;
    }
};
function createBaseCMsgGCCStrike15GotvSyncPacket() {
    return { data: undefined };
}
exports.CMsgGCCStrike15GotvSyncPacket = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.data !== undefined) {
            engine_gcmessages_1.CEngineGotvSyncPacket.encode(message.data, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15GotvSyncPacket();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.data = engine_gcmessages_1.CEngineGotvSyncPacket.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCMsgGCCStrike15GotvSyncPacket();
        message.data =
            object.data !== undefined && object.data !== null
                ? engine_gcmessages_1.CEngineGotvSyncPacket.fromPartial(object.data)
                : undefined;
        return message;
    }
};
function createBasePlayerDecalDigitalSignature() {
    return {
        signature: new Uint8Array(),
        accountid: 0,
        rtime: 0,
        endpos: [],
        startpos: [],
        right: [],
        txDefidx: 0,
        entindex: 0,
        hitbox: 0,
        creationtime: 0,
        equipslot: 0,
        traceId: 0,
        normal: [],
        tintId: 0
    };
}
exports.PlayerDecalDigitalSignature = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.signature.length !== 0) {
            writer.uint32(10).bytes(message.signature);
        }
        if (message.accountid !== 0) {
            writer.uint32(16).uint32(message.accountid);
        }
        if (message.rtime !== 0) {
            writer.uint32(24).uint32(message.rtime);
        }
        writer.uint32(34).fork();
        for (const v of message.endpos) {
            writer.float(v);
        }
        writer.ldelim();
        writer.uint32(42).fork();
        for (const v of message.startpos) {
            writer.float(v);
        }
        writer.ldelim();
        writer.uint32(50).fork();
        for (const v of message.right) {
            writer.float(v);
        }
        writer.ldelim();
        if (message.txDefidx !== 0) {
            writer.uint32(56).uint32(message.txDefidx);
        }
        if (message.entindex !== 0) {
            writer.uint32(64).int32(message.entindex);
        }
        if (message.hitbox !== 0) {
            writer.uint32(72).uint32(message.hitbox);
        }
        if (message.creationtime !== 0) {
            writer.uint32(85).float(message.creationtime);
        }
        if (message.equipslot !== 0) {
            writer.uint32(88).uint32(message.equipslot);
        }
        if (message.traceId !== 0) {
            writer.uint32(96).uint32(message.traceId);
        }
        writer.uint32(106).fork();
        for (const v of message.normal) {
            writer.float(v);
        }
        writer.ldelim();
        if (message.tintId !== 0) {
            writer.uint32(112).uint32(message.tintId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBasePlayerDecalDigitalSignature();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signature = reader.bytes();
                    break;
                case 2:
                    message.accountid = reader.uint32();
                    break;
                case 3:
                    message.rtime = reader.uint32();
                    break;
                case 4:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.endpos.push(reader.float());
                        }
                    }
                    else {
                        message.endpos.push(reader.float());
                    }
                    break;
                case 5:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.startpos.push(reader.float());
                        }
                    }
                    else {
                        message.startpos.push(reader.float());
                    }
                    break;
                case 6:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.right.push(reader.float());
                        }
                    }
                    else {
                        message.right.push(reader.float());
                    }
                    break;
                case 7:
                    message.txDefidx = reader.uint32();
                    break;
                case 8:
                    message.entindex = reader.int32();
                    break;
                case 9:
                    message.hitbox = reader.uint32();
                    break;
                case 10:
                    message.creationtime = reader.float();
                    break;
                case 11:
                    message.equipslot = reader.uint32();
                    break;
                case 12:
                    message.traceId = reader.uint32();
                    break;
                case 13:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.normal.push(reader.float());
                        }
                    }
                    else {
                        message.normal.push(reader.float());
                    }
                    break;
                case 14:
                    message.tintId = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
        const message = createBasePlayerDecalDigitalSignature();
        message.signature = (_a = object.signature) !== null && _a !== void 0 ? _a : new Uint8Array();
        message.accountid = (_b = object.accountid) !== null && _b !== void 0 ? _b : 0;
        message.rtime = (_c = object.rtime) !== null && _c !== void 0 ? _c : 0;
        message.endpos = ((_d = object.endpos) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];
        message.startpos = ((_e = object.startpos) === null || _e === void 0 ? void 0 : _e.map(e => e)) || [];
        message.right = ((_f = object.right) === null || _f === void 0 ? void 0 : _f.map(e => e)) || [];
        message.txDefidx = (_g = object.txDefidx) !== null && _g !== void 0 ? _g : 0;
        message.entindex = (_h = object.entindex) !== null && _h !== void 0 ? _h : 0;
        message.hitbox = (_j = object.hitbox) !== null && _j !== void 0 ? _j : 0;
        message.creationtime = (_k = object.creationtime) !== null && _k !== void 0 ? _k : 0;
        message.equipslot = (_l = object.equipslot) !== null && _l !== void 0 ? _l : 0;
        message.traceId = (_m = object.traceId) !== null && _m !== void 0 ? _m : 0;
        message.normal = ((_o = object.normal) === null || _o === void 0 ? void 0 : _o.map(e => e)) || [];
        message.tintId = (_p = object.tintId) !== null && _p !== void 0 ? _p : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientPlayerDecalSign() {
    return { data: undefined, itemid: Long.UZERO };
}
exports.CMsgGCCStrike15V2ClientPlayerDecalSign = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.data !== undefined) {
            exports.PlayerDecalDigitalSignature.encode(message.data, writer.uint32(10).fork()).ldelim();
        }
        if (!message.itemid.isZero()) {
            writer.uint32(16).uint64(message.itemid);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientPlayerDecalSign();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.data = exports.PlayerDecalDigitalSignature.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.itemid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCMsgGCCStrike15V2ClientPlayerDecalSign();
        message.data =
            object.data !== undefined && object.data !== null
                ? exports.PlayerDecalDigitalSignature.fromPartial(object.data)
                : undefined;
        message.itemid =
            object.itemid !== undefined && object.itemid !== null
                ? Long.fromValue(object.itemid)
                : Long.UZERO;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientLogonFatalError() {
    return { errorcode: 0, message: "", country: "" };
}
exports.CMsgGCCStrike15V2ClientLogonFatalError = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.errorcode !== 0) {
            writer.uint32(8).uint32(message.errorcode);
        }
        if (message.message !== "") {
            writer.uint32(18).string(message.message);
        }
        if (message.country !== "") {
            writer.uint32(26).string(message.country);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientLogonFatalError();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.errorcode = reader.uint32();
                    break;
                case 2:
                    message.message = reader.string();
                    break;
                case 3:
                    message.country = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCMsgGCCStrike15V2ClientLogonFatalError();
        message.errorcode = (_a = object.errorcode) !== null && _a !== void 0 ? _a : 0;
        message.message = (_b = object.message) !== null && _b !== void 0 ? _b : "";
        message.country = (_c = object.country) !== null && _c !== void 0 ? _c : "";
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientPollState() {
    return { pollid: 0, names: [], values: [] };
}
exports.CMsgGCCStrike15V2ClientPollState = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.pollid !== 0) {
            writer.uint32(8).uint32(message.pollid);
        }
        for (const v of message.names) {
            writer.uint32(18).string(v);
        }
        writer.uint32(26).fork();
        for (const v of message.values) {
            writer.int32(v);
        }
        writer.ldelim();
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientPollState();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.pollid = reader.uint32();
                    break;
                case 2:
                    message.names.push(reader.string());
                    break;
                case 3:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.values.push(reader.int32());
                        }
                    }
                    else {
                        message.values.push(reader.int32());
                    }
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCMsgGCCStrike15V2ClientPollState();
        message.pollid = (_a = object.pollid) !== null && _a !== void 0 ? _a : 0;
        message.names = ((_b = object.names) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];
        message.values = ((_c = object.values) === null || _c === void 0 ? void 0 : _c.map(e => e)) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2PartyRegister() {
    return {
        id: 0,
        ver: 0,
        apr: 0,
        ark: 0,
        nby: 0,
        grp: 0,
        slots: 0,
        launcher: 0,
        gameType: 0
    };
}
exports.CMsgGCCStrike15V2PartyRegister = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.id !== 0) {
            writer.uint32(8).uint32(message.id);
        }
        if (message.ver !== 0) {
            writer.uint32(16).uint32(message.ver);
        }
        if (message.apr !== 0) {
            writer.uint32(24).uint32(message.apr);
        }
        if (message.ark !== 0) {
            writer.uint32(32).uint32(message.ark);
        }
        if (message.nby !== 0) {
            writer.uint32(40).uint32(message.nby);
        }
        if (message.grp !== 0) {
            writer.uint32(48).uint32(message.grp);
        }
        if (message.slots !== 0) {
            writer.uint32(56).uint32(message.slots);
        }
        if (message.launcher !== 0) {
            writer.uint32(64).uint32(message.launcher);
        }
        if (message.gameType !== 0) {
            writer.uint32(72).uint32(message.gameType);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2PartyRegister();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.id = reader.uint32();
                    break;
                case 2:
                    message.ver = reader.uint32();
                    break;
                case 3:
                    message.apr = reader.uint32();
                    break;
                case 4:
                    message.ark = reader.uint32();
                    break;
                case 5:
                    message.nby = reader.uint32();
                    break;
                case 6:
                    message.grp = reader.uint32();
                    break;
                case 7:
                    message.slots = reader.uint32();
                    break;
                case 8:
                    message.launcher = reader.uint32();
                    break;
                case 9:
                    message.gameType = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
        const message = createBaseCMsgGCCStrike15V2PartyRegister();
        message.id = (_a = object.id) !== null && _a !== void 0 ? _a : 0;
        message.ver = (_b = object.ver) !== null && _b !== void 0 ? _b : 0;
        message.apr = (_c = object.apr) !== null && _c !== void 0 ? _c : 0;
        message.ark = (_d = object.ark) !== null && _d !== void 0 ? _d : 0;
        message.nby = (_e = object.nby) !== null && _e !== void 0 ? _e : 0;
        message.grp = (_f = object.grp) !== null && _f !== void 0 ? _f : 0;
        message.slots = (_g = object.slots) !== null && _g !== void 0 ? _g : 0;
        message.launcher = (_h = object.launcher) !== null && _h !== void 0 ? _h : 0;
        message.gameType = (_j = object.gameType) !== null && _j !== void 0 ? _j : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2PartySearch() {
    return { ver: 0, apr: 0, ark: 0, grps: [], launcher: 0, gameType: 0 };
}
exports.CMsgGCCStrike15V2PartySearch = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.ver !== 0) {
            writer.uint32(8).uint32(message.ver);
        }
        if (message.apr !== 0) {
            writer.uint32(16).uint32(message.apr);
        }
        if (message.ark !== 0) {
            writer.uint32(24).uint32(message.ark);
        }
        writer.uint32(34).fork();
        for (const v of message.grps) {
            writer.uint32(v);
        }
        writer.ldelim();
        if (message.launcher !== 0) {
            writer.uint32(40).uint32(message.launcher);
        }
        if (message.gameType !== 0) {
            writer.uint32(48).uint32(message.gameType);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2PartySearch();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.ver = reader.uint32();
                    break;
                case 2:
                    message.apr = reader.uint32();
                    break;
                case 3:
                    message.ark = reader.uint32();
                    break;
                case 4:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.grps.push(reader.uint32());
                        }
                    }
                    else {
                        message.grps.push(reader.uint32());
                    }
                    break;
                case 5:
                    message.launcher = reader.uint32();
                    break;
                case 6:
                    message.gameType = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f;
        const message = createBaseCMsgGCCStrike15V2PartySearch();
        message.ver = (_a = object.ver) !== null && _a !== void 0 ? _a : 0;
        message.apr = (_b = object.apr) !== null && _b !== void 0 ? _b : 0;
        message.ark = (_c = object.ark) !== null && _c !== void 0 ? _c : 0;
        message.grps = ((_d = object.grps) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];
        message.launcher = (_e = object.launcher) !== null && _e !== void 0 ? _e : 0;
        message.gameType = (_f = object.gameType) !== null && _f !== void 0 ? _f : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2PartySearchResults() {
    return { entries: [] };
}
exports.CMsgGCCStrike15V2PartySearchResults = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.entries) {
            exports.CMsgGCCStrike15V2PartySearchResults_Entry.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2PartySearchResults();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.entries.push(exports.CMsgGCCStrike15V2PartySearchResults_Entry.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2PartySearchResults();
        message.entries =
            ((_a = object.entries) === null || _a === void 0 ? void 0 : _a.map(e => exports.CMsgGCCStrike15V2PartySearchResults_Entry.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2PartySearchResults_Entry() {
    return { id: 0, grp: 0, gameType: 0, apr: 0, ark: 0, loc: 0, accountid: 0 };
}
exports.CMsgGCCStrike15V2PartySearchResults_Entry = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.id !== 0) {
            writer.uint32(8).uint32(message.id);
        }
        if (message.grp !== 0) {
            writer.uint32(16).uint32(message.grp);
        }
        if (message.gameType !== 0) {
            writer.uint32(24).uint32(message.gameType);
        }
        if (message.apr !== 0) {
            writer.uint32(32).uint32(message.apr);
        }
        if (message.ark !== 0) {
            writer.uint32(40).uint32(message.ark);
        }
        if (message.loc !== 0) {
            writer.uint32(48).uint32(message.loc);
        }
        if (message.accountid !== 0) {
            writer.uint32(56).uint32(message.accountid);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2PartySearchResults_Entry();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.id = reader.uint32();
                    break;
                case 2:
                    message.grp = reader.uint32();
                    break;
                case 3:
                    message.gameType = reader.uint32();
                    break;
                case 4:
                    message.apr = reader.uint32();
                    break;
                case 5:
                    message.ark = reader.uint32();
                    break;
                case 6:
                    message.loc = reader.uint32();
                    break;
                case 7:
                    message.accountid = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g;
        const message = createBaseCMsgGCCStrike15V2PartySearchResults_Entry();
        message.id = (_a = object.id) !== null && _a !== void 0 ? _a : 0;
        message.grp = (_b = object.grp) !== null && _b !== void 0 ? _b : 0;
        message.gameType = (_c = object.gameType) !== null && _c !== void 0 ? _c : 0;
        message.apr = (_d = object.apr) !== null && _d !== void 0 ? _d : 0;
        message.ark = (_e = object.ark) !== null && _e !== void 0 ? _e : 0;
        message.loc = (_f = object.loc) !== null && _f !== void 0 ? _f : 0;
        message.accountid = (_g = object.accountid) !== null && _g !== void 0 ? _g : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2PartyInvite() {
    return { accountid: 0, lobbyid: 0 };
}
exports.CMsgGCCStrike15V2PartyInvite = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountid !== 0) {
            writer.uint32(8).uint32(message.accountid);
        }
        if (message.lobbyid !== 0) {
            writer.uint32(16).uint32(message.lobbyid);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2PartyInvite();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountid = reader.uint32();
                    break;
                case 2:
                    message.lobbyid = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2PartyInvite();
        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;
        message.lobbyid = (_b = object.lobbyid) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2AccountRequestCoPlays() {
    return { players: [], servertime: 0 };
}
exports.CMsgGCCStrike15V2AccountRequestCoPlays = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.players) {
            exports.CMsgGCCStrike15V2AccountRequestCoPlays_Player.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.servertime !== 0) {
            writer.uint32(16).uint32(message.servertime);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2AccountRequestCoPlays();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.players.push(exports.CMsgGCCStrike15V2AccountRequestCoPlays_Player.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.servertime = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2AccountRequestCoPlays();
        message.players =
            ((_a = object.players) === null || _a === void 0 ? void 0 : _a.map(e => exports.CMsgGCCStrike15V2AccountRequestCoPlays_Player.fromPartial(e))) || [];
        message.servertime = (_b = object.servertime) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2AccountRequestCoPlays_Player() {
    return { accountid: 0, rtcoplay: 0, online: false };
}
exports.CMsgGCCStrike15V2AccountRequestCoPlays_Player = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountid !== 0) {
            writer.uint32(8).uint32(message.accountid);
        }
        if (message.rtcoplay !== 0) {
            writer.uint32(16).uint32(message.rtcoplay);
        }
        if (message.online === true) {
            writer.uint32(24).bool(message.online);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2AccountRequestCoPlays_Player();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountid = reader.uint32();
                    break;
                case 2:
                    message.rtcoplay = reader.uint32();
                    break;
                case 3:
                    message.online = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCMsgGCCStrike15V2AccountRequestCoPlays_Player();
        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;
        message.rtcoplay = (_b = object.rtcoplay) !== null && _b !== void 0 ? _b : 0;
        message.online = (_c = object.online) !== null && _c !== void 0 ? _c : false;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientToGCRequestTicket() {
    return {
        authorizedSteamId: Long.UZERO,
        authorizedPublicIp: 0,
        gameserverSteamId: Long.UZERO,
        gameserverSdrRouting: ""
    };
}
exports.CMsgGCCStrike15V2ClientToGCRequestTicket = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.authorizedSteamId.isZero()) {
            writer.uint32(9).fixed64(message.authorizedSteamId);
        }
        if (message.authorizedPublicIp !== 0) {
            writer.uint32(21).fixed32(message.authorizedPublicIp);
        }
        if (!message.gameserverSteamId.isZero()) {
            writer.uint32(25).fixed64(message.gameserverSteamId);
        }
        if (message.gameserverSdrRouting !== "") {
            writer.uint32(42).string(message.gameserverSdrRouting);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientToGCRequestTicket();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.authorizedSteamId = reader.fixed64();
                    break;
                case 2:
                    message.authorizedPublicIp = reader.fixed32();
                    break;
                case 3:
                    message.gameserverSteamId = reader.fixed64();
                    break;
                case 5:
                    message.gameserverSdrRouting = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2ClientToGCRequestTicket();
        message.authorizedSteamId =
            object.authorizedSteamId !== undefined &&
                object.authorizedSteamId !== null
                ? Long.fromValue(object.authorizedSteamId)
                : Long.UZERO;
        message.authorizedPublicIp = (_a = object.authorizedPublicIp) !== null && _a !== void 0 ? _a : 0;
        message.gameserverSteamId =
            object.gameserverSteamId !== undefined &&
                object.gameserverSteamId !== null
                ? Long.fromValue(object.gameserverSteamId)
                : Long.UZERO;
        message.gameserverSdrRouting = (_b = object.gameserverSdrRouting) !== null && _b !== void 0 ? _b : "";
        return message;
    }
};
function createBaseCMsgGCToClientSteamDatagramTicket() {
    return { serializedTicket: new Uint8Array() };
}
exports.CMsgGCToClientSteamDatagramTicket = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.serializedTicket.length !== 0) {
            writer.uint32(130).bytes(message.serializedTicket);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCToClientSteamDatagramTicket();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 16:
                    message.serializedTicket = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCToClientSteamDatagramTicket();
        message.serializedTicket = (_a = object.serializedTicket) !== null && _a !== void 0 ? _a : new Uint8Array();
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientRequestOffers() {
    return {};
}
exports.CMsgGCCStrike15V2ClientRequestOffers = {
    encode(_, writer = minimal_1.Writer.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientRequestOffers();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseCMsgGCCStrike15V2ClientRequestOffers();
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientRequestSouvenir() {
    return { itemid: Long.UZERO, matchid: Long.UZERO, eventid: 0 };
}
exports.CMsgGCCStrike15V2ClientRequestSouvenir = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.itemid.isZero()) {
            writer.uint32(8).uint64(message.itemid);
        }
        if (!message.matchid.isZero()) {
            writer.uint32(16).uint64(message.matchid);
        }
        if (message.eventid !== 0) {
            writer.uint32(24).int32(message.eventid);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientRequestSouvenir();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.itemid = reader.uint64();
                    break;
                case 2:
                    message.matchid = reader.uint64();
                    break;
                case 3:
                    message.eventid = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2ClientRequestSouvenir();
        message.itemid =
            object.itemid !== undefined && object.itemid !== null
                ? Long.fromValue(object.itemid)
                : Long.UZERO;
        message.matchid =
            object.matchid !== undefined && object.matchid !== null
                ? Long.fromValue(object.matchid)
                : Long.UZERO;
        message.eventid = (_a = object.eventid) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientAccountBalance() {
    return { amount: Long.UZERO, url: "" };
}
exports.CMsgGCCStrike15V2ClientAccountBalance = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.amount.isZero()) {
            writer.uint32(8).uint64(message.amount);
        }
        if (message.url !== "") {
            writer.uint32(18).string(message.url);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientAccountBalance();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.amount = reader.uint64();
                    break;
                case 2:
                    message.url = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2ClientAccountBalance();
        message.amount =
            object.amount !== undefined && object.amount !== null
                ? Long.fromValue(object.amount)
                : Long.UZERO;
        message.url = (_a = object.url) !== null && _a !== void 0 ? _a : "";
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientPartyJoinRelay() {
    return { accountid: 0, lobbyid: Long.UZERO };
}
exports.CMsgGCCStrike15V2ClientPartyJoinRelay = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountid !== 0) {
            writer.uint32(8).uint32(message.accountid);
        }
        if (!message.lobbyid.isZero()) {
            writer.uint32(16).uint64(message.lobbyid);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientPartyJoinRelay();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountid = reader.uint32();
                    break;
                case 2:
                    message.lobbyid = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2ClientPartyJoinRelay();
        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;
        message.lobbyid =
            object.lobbyid !== undefined && object.lobbyid !== null
                ? Long.fromValue(object.lobbyid)
                : Long.UZERO;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientPartyWarning() {
    return { entries: [] };
}
exports.CMsgGCCStrike15V2ClientPartyWarning = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.entries) {
            exports.CMsgGCCStrike15V2ClientPartyWarning_Entry.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientPartyWarning();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.entries.push(exports.CMsgGCCStrike15V2ClientPartyWarning_Entry.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2ClientPartyWarning();
        message.entries =
            ((_a = object.entries) === null || _a === void 0 ? void 0 : _a.map(e => exports.CMsgGCCStrike15V2ClientPartyWarning_Entry.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientPartyWarning_Entry() {
    return { accountid: 0, warntype: 0 };
}
exports.CMsgGCCStrike15V2ClientPartyWarning_Entry = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountid !== 0) {
            writer.uint32(8).uint32(message.accountid);
        }
        if (message.warntype !== 0) {
            writer.uint32(16).uint32(message.warntype);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientPartyWarning_Entry();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountid = reader.uint32();
                    break;
                case 2:
                    message.warntype = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2ClientPartyWarning_Entry();
        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;
        message.warntype = (_b = object.warntype) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2SetEventFavorite() {
    return { eventid: Long.UZERO, isFavorite: false };
}
exports.CMsgGCCStrike15V2SetEventFavorite = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.eventid.isZero()) {
            writer.uint32(8).uint64(message.eventid);
        }
        if (message.isFavorite === true) {
            writer.uint32(16).bool(message.isFavorite);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2SetEventFavorite();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.eventid = reader.uint64();
                    break;
                case 2:
                    message.isFavorite = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2SetEventFavorite();
        message.eventid =
            object.eventid !== undefined && object.eventid !== null
                ? Long.fromValue(object.eventid)
                : Long.UZERO;
        message.isFavorite = (_a = object.isFavorite) !== null && _a !== void 0 ? _a : false;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2GetEventFavoritesRequest() {
    return { allEvents: false };
}
exports.CMsgGCCStrike15V2GetEventFavoritesRequest = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.allEvents === true) {
            writer.uint32(8).bool(message.allEvents);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2GetEventFavoritesRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.allEvents = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2GetEventFavoritesRequest();
        message.allEvents = (_a = object.allEvents) !== null && _a !== void 0 ? _a : false;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2GetEventFavoritesResponse() {
    return { allEvents: false, jsonFavorites: "", jsonFeatured: "" };
}
exports.CMsgGCCStrike15V2GetEventFavoritesResponse = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.allEvents === true) {
            writer.uint32(8).bool(message.allEvents);
        }
        if (message.jsonFavorites !== "") {
            writer.uint32(18).string(message.jsonFavorites);
        }
        if (message.jsonFeatured !== "") {
            writer.uint32(26).string(message.jsonFeatured);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2GetEventFavoritesResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.allEvents = reader.bool();
                    break;
                case 2:
                    message.jsonFavorites = reader.string();
                    break;
                case 3:
                    message.jsonFeatured = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCMsgGCCStrike15V2GetEventFavoritesResponse();
        message.allEvents = (_a = object.allEvents) !== null && _a !== void 0 ? _a : false;
        message.jsonFavorites = (_b = object.jsonFavorites) !== null && _b !== void 0 ? _b : "";
        message.jsonFeatured = (_c = object.jsonFeatured) !== null && _c !== void 0 ? _c : "";
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientPerfReport() {
    return { entries: [] };
}
exports.CMsgGCCStrike15V2ClientPerfReport = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.entries) {
            exports.CMsgGCCStrike15V2ClientPerfReport_Entry.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientPerfReport();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.entries.push(exports.CMsgGCCStrike15V2ClientPerfReport_Entry.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgGCCStrike15V2ClientPerfReport();
        message.entries =
            ((_a = object.entries) === null || _a === void 0 ? void 0 : _a.map(e => exports.CMsgGCCStrike15V2ClientPerfReport_Entry.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientPerfReport_Entry() {
    return {
        perfcounter: 0,
        length: 0,
        reference: new Uint8Array(),
        actual: new Uint8Array(),
        sourceid: 0,
        status: 0
    };
}
exports.CMsgGCCStrike15V2ClientPerfReport_Entry = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.perfcounter !== 0) {
            writer.uint32(8).uint32(message.perfcounter);
        }
        if (message.length !== 0) {
            writer.uint32(16).uint32(message.length);
        }
        if (message.reference.length !== 0) {
            writer.uint32(26).bytes(message.reference);
        }
        if (message.actual.length !== 0) {
            writer.uint32(34).bytes(message.actual);
        }
        if (message.sourceid !== 0) {
            writer.uint32(40).uint32(message.sourceid);
        }
        if (message.status !== 0) {
            writer.uint32(48).uint32(message.status);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientPerfReport_Entry();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.perfcounter = reader.uint32();
                    break;
                case 2:
                    message.length = reader.uint32();
                    break;
                case 3:
                    message.reference = reader.bytes();
                    break;
                case 4:
                    message.actual = reader.bytes();
                    break;
                case 5:
                    message.sourceid = reader.uint32();
                    break;
                case 6:
                    message.status = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f;
        const message = createBaseCMsgGCCStrike15V2ClientPerfReport_Entry();
        message.perfcounter = (_a = object.perfcounter) !== null && _a !== void 0 ? _a : 0;
        message.length = (_b = object.length) !== null && _b !== void 0 ? _b : 0;
        message.reference = (_c = object.reference) !== null && _c !== void 0 ? _c : new Uint8Array();
        message.actual = (_d = object.actual) !== null && _d !== void 0 ? _d : new Uint8Array();
        message.sourceid = (_e = object.sourceid) !== null && _e !== void 0 ? _e : 0;
        message.status = (_f = object.status) !== null && _f !== void 0 ? _f : 0;
        return message;
    }
};
function createBaseCVDiagnostic() {
    return { id: 0, extended: 0, value: Long.UZERO, stringValue: "" };
}
exports.CVDiagnostic = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.id !== 0) {
            writer.uint32(8).uint32(message.id);
        }
        if (message.extended !== 0) {
            writer.uint32(16).uint32(message.extended);
        }
        if (!message.value.isZero()) {
            writer.uint32(24).uint64(message.value);
        }
        if (message.stringValue !== "") {
            writer.uint32(34).string(message.stringValue);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCVDiagnostic();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.id = reader.uint32();
                    break;
                case 2:
                    message.extended = reader.uint32();
                    break;
                case 3:
                    message.value = reader.uint64();
                    break;
                case 4:
                    message.stringValue = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCVDiagnostic();
        message.id = (_a = object.id) !== null && _a !== void 0 ? _a : 0;
        message.extended = (_b = object.extended) !== null && _b !== void 0 ? _b : 0;
        message.value =
            object.value !== undefined && object.value !== null
                ? Long.fromValue(object.value)
                : Long.UZERO;
        message.stringValue = (_c = object.stringValue) !== null && _c !== void 0 ? _c : "";
        return message;
    }
};
function createBaseCMsgGCCStrike15V2ClientReportValidation() {
    return {
        fileReport: "",
        commandLine: "",
        totalFiles: 0,
        internalError: 0,
        trustTime: 0,
        countPending: 0,
        countCompleted: 0,
        processId: 0,
        osversion: 0,
        clientreportversion: 0,
        statusId: 0,
        diagnostic1: 0,
        diagnostic2: Long.UZERO,
        diagnostic3: Long.UZERO,
        lastLaunchData: "",
        reportCount: 0,
        clientTime: Long.UZERO,
        diagnostic4: Long.UZERO,
        diagnostic5: Long.UZERO,
        diagnostics: []
    };
}
exports.CMsgGCCStrike15V2ClientReportValidation = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.fileReport !== "") {
            writer.uint32(10).string(message.fileReport);
        }
        if (message.commandLine !== "") {
            writer.uint32(18).string(message.commandLine);
        }
        if (message.totalFiles !== 0) {
            writer.uint32(24).uint32(message.totalFiles);
        }
        if (message.internalError !== 0) {
            writer.uint32(32).uint32(message.internalError);
        }
        if (message.trustTime !== 0) {
            writer.uint32(40).uint32(message.trustTime);
        }
        if (message.countPending !== 0) {
            writer.uint32(48).uint32(message.countPending);
        }
        if (message.countCompleted !== 0) {
            writer.uint32(56).uint32(message.countCompleted);
        }
        if (message.processId !== 0) {
            writer.uint32(64).uint32(message.processId);
        }
        if (message.osversion !== 0) {
            writer.uint32(72).int32(message.osversion);
        }
        if (message.clientreportversion !== 0) {
            writer.uint32(80).uint32(message.clientreportversion);
        }
        if (message.statusId !== 0) {
            writer.uint32(88).uint32(message.statusId);
        }
        if (message.diagnostic1 !== 0) {
            writer.uint32(96).uint32(message.diagnostic1);
        }
        if (!message.diagnostic2.isZero()) {
            writer.uint32(104).uint64(message.diagnostic2);
        }
        if (!message.diagnostic3.isZero()) {
            writer.uint32(112).uint64(message.diagnostic3);
        }
        if (message.lastLaunchData !== "") {
            writer.uint32(122).string(message.lastLaunchData);
        }
        if (message.reportCount !== 0) {
            writer.uint32(128).uint32(message.reportCount);
        }
        if (!message.clientTime.isZero()) {
            writer.uint32(136).uint64(message.clientTime);
        }
        if (!message.diagnostic4.isZero()) {
            writer.uint32(144).uint64(message.diagnostic4);
        }
        if (!message.diagnostic5.isZero()) {
            writer.uint32(152).uint64(message.diagnostic5);
        }
        for (const v of message.diagnostics) {
            exports.CVDiagnostic.encode(v, writer.uint32(162).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2ClientReportValidation();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.fileReport = reader.string();
                    break;
                case 2:
                    message.commandLine = reader.string();
                    break;
                case 3:
                    message.totalFiles = reader.uint32();
                    break;
                case 4:
                    message.internalError = reader.uint32();
                    break;
                case 5:
                    message.trustTime = reader.uint32();
                    break;
                case 6:
                    message.countPending = reader.uint32();
                    break;
                case 7:
                    message.countCompleted = reader.uint32();
                    break;
                case 8:
                    message.processId = reader.uint32();
                    break;
                case 9:
                    message.osversion = reader.int32();
                    break;
                case 10:
                    message.clientreportversion = reader.uint32();
                    break;
                case 11:
                    message.statusId = reader.uint32();
                    break;
                case 12:
                    message.diagnostic1 = reader.uint32();
                    break;
                case 13:
                    message.diagnostic2 = reader.uint64();
                    break;
                case 14:
                    message.diagnostic3 = reader.uint64();
                    break;
                case 15:
                    message.lastLaunchData = reader.string();
                    break;
                case 16:
                    message.reportCount = reader.uint32();
                    break;
                case 17:
                    message.clientTime = reader.uint64();
                    break;
                case 18:
                    message.diagnostic4 = reader.uint64();
                    break;
                case 19:
                    message.diagnostic5 = reader.uint64();
                    break;
                case 20:
                    message.diagnostics.push(exports.CVDiagnostic.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
        const message = createBaseCMsgGCCStrike15V2ClientReportValidation();
        message.fileReport = (_a = object.fileReport) !== null && _a !== void 0 ? _a : "";
        message.commandLine = (_b = object.commandLine) !== null && _b !== void 0 ? _b : "";
        message.totalFiles = (_c = object.totalFiles) !== null && _c !== void 0 ? _c : 0;
        message.internalError = (_d = object.internalError) !== null && _d !== void 0 ? _d : 0;
        message.trustTime = (_e = object.trustTime) !== null && _e !== void 0 ? _e : 0;
        message.countPending = (_f = object.countPending) !== null && _f !== void 0 ? _f : 0;
        message.countCompleted = (_g = object.countCompleted) !== null && _g !== void 0 ? _g : 0;
        message.processId = (_h = object.processId) !== null && _h !== void 0 ? _h : 0;
        message.osversion = (_j = object.osversion) !== null && _j !== void 0 ? _j : 0;
        message.clientreportversion = (_k = object.clientreportversion) !== null && _k !== void 0 ? _k : 0;
        message.statusId = (_l = object.statusId) !== null && _l !== void 0 ? _l : 0;
        message.diagnostic1 = (_m = object.diagnostic1) !== null && _m !== void 0 ? _m : 0;
        message.diagnostic2 =
            object.diagnostic2 !== undefined && object.diagnostic2 !== null
                ? Long.fromValue(object.diagnostic2)
                : Long.UZERO;
        message.diagnostic3 =
            object.diagnostic3 !== undefined && object.diagnostic3 !== null
                ? Long.fromValue(object.diagnostic3)
                : Long.UZERO;
        message.lastLaunchData = (_o = object.lastLaunchData) !== null && _o !== void 0 ? _o : "";
        message.reportCount = (_p = object.reportCount) !== null && _p !== void 0 ? _p : 0;
        message.clientTime =
            object.clientTime !== undefined && object.clientTime !== null
                ? Long.fromValue(object.clientTime)
                : Long.UZERO;
        message.diagnostic4 =
            object.diagnostic4 !== undefined && object.diagnostic4 !== null
                ? Long.fromValue(object.diagnostic4)
                : Long.UZERO;
        message.diagnostic5 =
            object.diagnostic5 !== undefined && object.diagnostic5 !== null
                ? Long.fromValue(object.diagnostic5)
                : Long.UZERO;
        message.diagnostics =
            ((_q = object.diagnostics) === null || _q === void 0 ? void 0 : _q.map(e => exports.CVDiagnostic.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCMsgGCCStrike15V2GC2ClientRefuseSecureMode() {
    return {
        fileReport: "",
        offerInsecureMode: false,
        offerSecureMode: false,
        showUnsignedUi: false,
        kickUser: false,
        showTrustedUi: false,
        showWarningNotTrusted: false,
        showWarningNotTrusted2: false,
        filesPreventedTrusted: ""
    };
}
exports.CMsgGCCStrike15V2GC2ClientRefuseSecureMode = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.fileReport !== "") {
            writer.uint32(10).string(message.fileReport);
        }
        if (message.offerInsecureMode === true) {
            writer.uint32(16).bool(message.offerInsecureMode);
        }
        if (message.offerSecureMode === true) {
            writer.uint32(24).bool(message.offerSecureMode);
        }
        if (message.showUnsignedUi === true) {
            writer.uint32(32).bool(message.showUnsignedUi);
        }
        if (message.kickUser === true) {
            writer.uint32(40).bool(message.kickUser);
        }
        if (message.showTrustedUi === true) {
            writer.uint32(48).bool(message.showTrustedUi);
        }
        if (message.showWarningNotTrusted === true) {
            writer.uint32(56).bool(message.showWarningNotTrusted);
        }
        if (message.showWarningNotTrusted2 === true) {
            writer.uint32(64).bool(message.showWarningNotTrusted2);
        }
        if (message.filesPreventedTrusted !== "") {
            writer.uint32(74).string(message.filesPreventedTrusted);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2GC2ClientRefuseSecureMode();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.fileReport = reader.string();
                    break;
                case 2:
                    message.offerInsecureMode = reader.bool();
                    break;
                case 3:
                    message.offerSecureMode = reader.bool();
                    break;
                case 4:
                    message.showUnsignedUi = reader.bool();
                    break;
                case 5:
                    message.kickUser = reader.bool();
                    break;
                case 6:
                    message.showTrustedUi = reader.bool();
                    break;
                case 7:
                    message.showWarningNotTrusted = reader.bool();
                    break;
                case 8:
                    message.showWarningNotTrusted2 = reader.bool();
                    break;
                case 9:
                    message.filesPreventedTrusted = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
        const message = createBaseCMsgGCCStrike15V2GC2ClientRefuseSecureMode();
        message.fileReport = (_a = object.fileReport) !== null && _a !== void 0 ? _a : "";
        message.offerInsecureMode = (_b = object.offerInsecureMode) !== null && _b !== void 0 ? _b : false;
        message.offerSecureMode = (_c = object.offerSecureMode) !== null && _c !== void 0 ? _c : false;
        message.showUnsignedUi = (_d = object.showUnsignedUi) !== null && _d !== void 0 ? _d : false;
        message.kickUser = (_e = object.kickUser) !== null && _e !== void 0 ? _e : false;
        message.showTrustedUi = (_f = object.showTrustedUi) !== null && _f !== void 0 ? _f : false;
        message.showWarningNotTrusted = (_g = object.showWarningNotTrusted) !== null && _g !== void 0 ? _g : false;
        message.showWarningNotTrusted2 = (_h = object.showWarningNotTrusted2) !== null && _h !== void 0 ? _h : false;
        message.filesPreventedTrusted = (_j = object.filesPreventedTrusted) !== null && _j !== void 0 ? _j : "";
        return message;
    }
};
function createBaseCMsgGCCStrike15V2GC2ClientRequestValidation() {
    return { fullReport: false, module: "" };
}
exports.CMsgGCCStrike15V2GC2ClientRequestValidation = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.fullReport === true) {
            writer.uint32(8).bool(message.fullReport);
        }
        if (message.module !== "") {
            writer.uint32(18).string(message.module);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2GC2ClientRequestValidation();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.fullReport = reader.bool();
                    break;
                case 2:
                    message.module = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgGCCStrike15V2GC2ClientRequestValidation();
        message.fullReport = (_a = object.fullReport) !== null && _a !== void 0 ? _a : false;
        message.module = (_b = object.module) !== null && _b !== void 0 ? _b : "";
        return message;
    }
};
function createBaseCMsgGCCStrike15V2GC2ClientInitSystem() {
    return {
        load: false,
        name: "",
        outputname: "",
        keyData: new Uint8Array(),
        shaHash: new Uint8Array(),
        cookie: 0,
        manifest: "",
        systemPackage: new Uint8Array(),
        loadSystem: false
    };
}
exports.CMsgGCCStrike15V2GC2ClientInitSystem = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.load === true) {
            writer.uint32(8).bool(message.load);
        }
        if (message.name !== "") {
            writer.uint32(18).string(message.name);
        }
        if (message.outputname !== "") {
            writer.uint32(26).string(message.outputname);
        }
        if (message.keyData.length !== 0) {
            writer.uint32(34).bytes(message.keyData);
        }
        if (message.shaHash.length !== 0) {
            writer.uint32(42).bytes(message.shaHash);
        }
        if (message.cookie !== 0) {
            writer.uint32(48).int32(message.cookie);
        }
        if (message.manifest !== "") {
            writer.uint32(58).string(message.manifest);
        }
        if (message.systemPackage.length !== 0) {
            writer.uint32(66).bytes(message.systemPackage);
        }
        if (message.loadSystem === true) {
            writer.uint32(72).bool(message.loadSystem);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2GC2ClientInitSystem();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.load = reader.bool();
                    break;
                case 2:
                    message.name = reader.string();
                    break;
                case 3:
                    message.outputname = reader.string();
                    break;
                case 4:
                    message.keyData = reader.bytes();
                    break;
                case 5:
                    message.shaHash = reader.bytes();
                    break;
                case 6:
                    message.cookie = reader.int32();
                    break;
                case 7:
                    message.manifest = reader.string();
                    break;
                case 8:
                    message.systemPackage = reader.bytes();
                    break;
                case 9:
                    message.loadSystem = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
        const message = createBaseCMsgGCCStrike15V2GC2ClientInitSystem();
        message.load = (_a = object.load) !== null && _a !== void 0 ? _a : false;
        message.name = (_b = object.name) !== null && _b !== void 0 ? _b : "";
        message.outputname = (_c = object.outputname) !== null && _c !== void 0 ? _c : "";
        message.keyData = (_d = object.keyData) !== null && _d !== void 0 ? _d : new Uint8Array();
        message.shaHash = (_e = object.shaHash) !== null && _e !== void 0 ? _e : new Uint8Array();
        message.cookie = (_f = object.cookie) !== null && _f !== void 0 ? _f : 0;
        message.manifest = (_g = object.manifest) !== null && _g !== void 0 ? _g : "";
        message.systemPackage = (_h = object.systemPackage) !== null && _h !== void 0 ? _h : new Uint8Array();
        message.loadSystem = (_j = object.loadSystem) !== null && _j !== void 0 ? _j : false;
        return message;
    }
};
function createBaseCMsgGCCStrike15V2GC2ClientInitSystemResponse() {
    return {
        success: false,
        diagnostic: "",
        shaHash: new Uint8Array(),
        response: 0,
        errorCode1: 0,
        errorCode2: 0,
        handle: Long.ZERO,
        einitResult: 0,
        auxSystem1: 0,
        auxSystem2: 0
    };
}
exports.CMsgGCCStrike15V2GC2ClientInitSystemResponse = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.success === true) {
            writer.uint32(8).bool(message.success);
        }
        if (message.diagnostic !== "") {
            writer.uint32(18).string(message.diagnostic);
        }
        if (message.shaHash.length !== 0) {
            writer.uint32(26).bytes(message.shaHash);
        }
        if (message.response !== 0) {
            writer.uint32(32).int32(message.response);
        }
        if (message.errorCode1 !== 0) {
            writer.uint32(40).int32(message.errorCode1);
        }
        if (message.errorCode2 !== 0) {
            writer.uint32(48).int32(message.errorCode2);
        }
        if (!message.handle.isZero()) {
            writer.uint32(56).int64(message.handle);
        }
        if (message.einitResult !== 0) {
            writer.uint32(64).int32(message.einitResult);
        }
        if (message.auxSystem1 !== 0) {
            writer.uint32(72).int32(message.auxSystem1);
        }
        if (message.auxSystem2 !== 0) {
            writer.uint32(80).int32(message.auxSystem2);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgGCCStrike15V2GC2ClientInitSystemResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.success = reader.bool();
                    break;
                case 2:
                    message.diagnostic = reader.string();
                    break;
                case 3:
                    message.shaHash = reader.bytes();
                    break;
                case 4:
                    message.response = reader.int32();
                    break;
                case 5:
                    message.errorCode1 = reader.int32();
                    break;
                case 6:
                    message.errorCode2 = reader.int32();
                    break;
                case 7:
                    message.handle = reader.int64();
                    break;
                case 8:
                    message.einitResult = reader.int32();
                    break;
                case 9:
                    message.auxSystem1 = reader.int32();
                    break;
                case 10:
                    message.auxSystem2 = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
        const message = createBaseCMsgGCCStrike15V2GC2ClientInitSystemResponse();
        message.success = (_a = object.success) !== null && _a !== void 0 ? _a : false;
        message.diagnostic = (_b = object.diagnostic) !== null && _b !== void 0 ? _b : "";
        message.shaHash = (_c = object.shaHash) !== null && _c !== void 0 ? _c : new Uint8Array();
        message.response = (_d = object.response) !== null && _d !== void 0 ? _d : 0;
        message.errorCode1 = (_e = object.errorCode1) !== null && _e !== void 0 ? _e : 0;
        message.errorCode2 = (_f = object.errorCode2) !== null && _f !== void 0 ? _f : 0;
        message.handle =
            object.handle !== undefined && object.handle !== null
                ? Long.fromValue(object.handle)
                : Long.ZERO;
        message.einitResult = (_g = object.einitResult) !== null && _g !== void 0 ? _g : 0;
        message.auxSystem1 = (_h = object.auxSystem1) !== null && _h !== void 0 ? _h : 0;
        message.auxSystem2 = (_j = object.auxSystem2) !== null && _j !== void 0 ? _j : 0;
        return message;
    }
};
// If you get a compile-error about 'Constructor<Long> and ... have no overlap',
// add '--ts_proto_opt=esModuleInterop=true' as a flag when calling 'protoc'.
if (minimal_1.util.Long !== Long) {
    minimal_1.util.Long = Long;
    (0, minimal_1.configure)();
}

},{"./engine_gcmessages":26,"long":712,"protobufjs/minimal":715}],25:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CCSUsrMsgVoteStart = exports.CCSUsrMsgCallVoteFailed = exports.CCSUsrMsgXRankUpd = exports.CCSUsrMsgXRankGet = exports.CCSUsrMsgPlayerDecalDigitalSignature = exports.CCSUsrMsgScoreLeaderboardData = exports.CCSUsrMsgQuestProgress = exports.CCSUsrMsgDisplayInventory = exports.CCSUsrMsgPlayerStatsUpdate_Stat = exports.CCSUsrMsgPlayerStatsUpdate = exports.CCSUsrMsgMatchEndConditions = exports.CCSUsrMsgAchievementEvent = exports.CCSUsrMsgCurrentTimescale = exports.CCSUsrMsgDesiredTimescale = exports.CCSUsrMsgKillCam = exports.CCSUsrMsgReportHit = exports.CCSUsrMsgAdjustMoney = exports.CCSUsrMsgEntityOutlineHighlight = exports.CCSUsrMsgUpdateScreenHealthBar = exports.CCSUsrMsgWeaponSound = exports.CCSUsrMsgReloadEffect = exports.CCSUsrMsgSendPlayerItemFound = exports.CCSUsrMsgSendPlayerItemDrops = exports.CCSUsrMsgProcessSpottedEntityUpdate_SpottedEntityUpdate = exports.CCSUsrMsgProcessSpottedEntityUpdate = exports.CCSUsrMsgKeyHintText = exports.CCSUsrMsgHintText = exports.CCSUsrMsgRadioText = exports.CCSUsrMsgDamage = exports.CCSUsrMsgVoiceMask_PlayerMask = exports.CCSUsrMsgVoiceMask = exports.CCSUsrMsgRawAudio = exports.CCSUsrMsgSendAudio = exports.CCSUsrMsgCloseCaptionDirect = exports.CCSUsrMsgCloseCaption = exports.CCSUsrMsgRumble = exports.CCSUsrMsgFade = exports.CCSUsrMsgShake = exports.CCSUsrMsgHudMsg = exports.CCSUsrMsgTextMsg = exports.CCSUsrMsgSayText2 = exports.CCSUsrMsgSayText = exports.CCSUsrMsgHudText = exports.CCSUsrMsgTrain = exports.CCSUsrMsgGeiger = exports.CCSUsrMsgVGUIMenu_Subkey = exports.CCSUsrMsgVGUIMenu = exports.ECSUsrMsgDisconnectToLobbyAction = exports.ECstrike15UserMessages = exports.protobufPackage = void 0;
exports.CCSUsrMsgUtilMsg = exports.CCSUsrMsgServerRankRevealAll = exports.CCSUsrMsgClientInfo = exports.CCSUsrMsgWarmupHasEnded = exports.CCSUsrMsgDisconnectToLobby = exports.CCSUsrMsgStopSpectatorMode = exports.CCSUsrMsgRequestState = exports.CCSUsrMsgGameTitle = exports.CCSUsrMsgResetHud = exports.CCSUsrMsgDeepStats = exports.CCSUsrMsgCurrentRoundOdds = exports.CCSUsrMsgRoundImpactScoreData_InitialConditions = exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Damage = exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Objective = exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Victim = exports.CCSUsrMsgRoundImpactScoreData_RisEvent = exports.CCSUsrMsgRoundImpactScoreData = exports.CCSUsrMsgEndOfMatchAllPlayersData_PlayerData = exports.CCSUsrMsgEndOfMatchAllPlayersData_Accolade = exports.CCSUsrMsgEndOfMatchAllPlayersData = exports.CCSUsrMsgSurvivalStats_Damage = exports.CCSUsrMsgSurvivalStats_Placement = exports.CCSUsrMsgSurvivalStats_Fact = exports.CCSUsrMsgSurvivalStats = exports.CCSUsrMsgSSUI = exports.CCSUsrMsgRoundBackupFilenames = exports.CCSUsrMsgGlowPropTurnOff = exports.CCSUsrMsgItemDrop = exports.CCSUsrMsgMatchStatsUpdate = exports.CCSUsrMsgMarkAchievement = exports.CCSUsrMsgAmmoDenied = exports.CCSUsrMsgBarTime = exports.CCSUsrMsgShowMenu = exports.CCSUsrMsgItemPickup = exports.CCSUsrMsgXpUpdate = exports.CCSUsrMsgServerRankUpdate_RankUpdate = exports.CCSUsrMsgServerRankUpdate = exports.CCSUsrMsgSendLastKillerDamageToClient = exports.CCSUsrMsgVoteSetup = exports.CCSUsrMsgVoteFailed = exports.CCSUsrMsgVotePass = void 0;
/* eslint-disable */
const minimal_1 = require("protobufjs/minimal");
const Long = require("long");
const netmessages_1 = require("./netmessages");
const cstrike15_gcmessages_1 = require("./cstrike15_gcmessages");
exports.protobufPackage = "";
var ECstrike15UserMessages;
(function (ECstrike15UserMessages) {
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_VGUIMenu"] = 1] = "CS_UM_VGUIMenu";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_Geiger"] = 2] = "CS_UM_Geiger";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_Train"] = 3] = "CS_UM_Train";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_HudText"] = 4] = "CS_UM_HudText";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_SayText"] = 5] = "CS_UM_SayText";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_SayText2"] = 6] = "CS_UM_SayText2";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_TextMsg"] = 7] = "CS_UM_TextMsg";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_HudMsg"] = 8] = "CS_UM_HudMsg";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_ResetHud"] = 9] = "CS_UM_ResetHud";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_GameTitle"] = 10] = "CS_UM_GameTitle";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_Shake"] = 12] = "CS_UM_Shake";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_Fade"] = 13] = "CS_UM_Fade";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_Rumble"] = 14] = "CS_UM_Rumble";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_CloseCaption"] = 15] = "CS_UM_CloseCaption";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_CloseCaptionDirect"] = 16] = "CS_UM_CloseCaptionDirect";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_SendAudio"] = 17] = "CS_UM_SendAudio";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_RawAudio"] = 18] = "CS_UM_RawAudio";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_VoiceMask"] = 19] = "CS_UM_VoiceMask";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_RequestState"] = 20] = "CS_UM_RequestState";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_Damage"] = 21] = "CS_UM_Damage";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_RadioText"] = 22] = "CS_UM_RadioText";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_HintText"] = 23] = "CS_UM_HintText";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_KeyHintText"] = 24] = "CS_UM_KeyHintText";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_ProcessSpottedEntityUpdate"] = 25] = "CS_UM_ProcessSpottedEntityUpdate";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_ReloadEffect"] = 26] = "CS_UM_ReloadEffect";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_AdjustMoney"] = 27] = "CS_UM_AdjustMoney";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_UpdateTeamMoney"] = 28] = "CS_UM_UpdateTeamMoney";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_StopSpectatorMode"] = 29] = "CS_UM_StopSpectatorMode";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_KillCam"] = 30] = "CS_UM_KillCam";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_DesiredTimescale"] = 31] = "CS_UM_DesiredTimescale";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_CurrentTimescale"] = 32] = "CS_UM_CurrentTimescale";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_AchievementEvent"] = 33] = "CS_UM_AchievementEvent";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_MatchEndConditions"] = 34] = "CS_UM_MatchEndConditions";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_DisconnectToLobby"] = 35] = "CS_UM_DisconnectToLobby";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_PlayerStatsUpdate"] = 36] = "CS_UM_PlayerStatsUpdate";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_DisplayInventory"] = 37] = "CS_UM_DisplayInventory";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_WarmupHasEnded"] = 38] = "CS_UM_WarmupHasEnded";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_ClientInfo"] = 39] = "CS_UM_ClientInfo";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_XRankGet"] = 40] = "CS_UM_XRankGet";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_XRankUpd"] = 41] = "CS_UM_XRankUpd";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_CallVoteFailed"] = 45] = "CS_UM_CallVoteFailed";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_VoteStart"] = 46] = "CS_UM_VoteStart";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_VotePass"] = 47] = "CS_UM_VotePass";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_VoteFailed"] = 48] = "CS_UM_VoteFailed";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_VoteSetup"] = 49] = "CS_UM_VoteSetup";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_ServerRankRevealAll"] = 50] = "CS_UM_ServerRankRevealAll";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_SendLastKillerDamageToClient"] = 51] = "CS_UM_SendLastKillerDamageToClient";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_ServerRankUpdate"] = 52] = "CS_UM_ServerRankUpdate";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_ItemPickup"] = 53] = "CS_UM_ItemPickup";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_ShowMenu"] = 54] = "CS_UM_ShowMenu";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_BarTime"] = 55] = "CS_UM_BarTime";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_AmmoDenied"] = 56] = "CS_UM_AmmoDenied";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_MarkAchievement"] = 57] = "CS_UM_MarkAchievement";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_MatchStatsUpdate"] = 58] = "CS_UM_MatchStatsUpdate";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_ItemDrop"] = 59] = "CS_UM_ItemDrop";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_GlowPropTurnOff"] = 60] = "CS_UM_GlowPropTurnOff";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_SendPlayerItemDrops"] = 61] = "CS_UM_SendPlayerItemDrops";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_RoundBackupFilenames"] = 62] = "CS_UM_RoundBackupFilenames";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_SendPlayerItemFound"] = 63] = "CS_UM_SendPlayerItemFound";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_ReportHit"] = 64] = "CS_UM_ReportHit";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_XpUpdate"] = 65] = "CS_UM_XpUpdate";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_QuestProgress"] = 66] = "CS_UM_QuestProgress";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_ScoreLeaderboardData"] = 67] = "CS_UM_ScoreLeaderboardData";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_PlayerDecalDigitalSignature"] = 68] = "CS_UM_PlayerDecalDigitalSignature";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_WeaponSound"] = 69] = "CS_UM_WeaponSound";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_UpdateScreenHealthBar"] = 70] = "CS_UM_UpdateScreenHealthBar";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_EntityOutlineHighlight"] = 71] = "CS_UM_EntityOutlineHighlight";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_SSUI"] = 72] = "CS_UM_SSUI";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_SurvivalStats"] = 73] = "CS_UM_SurvivalStats";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_DisconnectToLobby2"] = 74] = "CS_UM_DisconnectToLobby2";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_EndOfMatchAllPlayersData"] = 75] = "CS_UM_EndOfMatchAllPlayersData";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_RoundImpactScoreData"] = 79] = "CS_UM_RoundImpactScoreData";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_CurrentRoundOdds"] = 80] = "CS_UM_CurrentRoundOdds";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_DeepStats"] = 81] = "CS_UM_DeepStats";
    ECstrike15UserMessages[ECstrike15UserMessages["CS_UM_UtilMsg"] = 82] = "CS_UM_UtilMsg";
})(ECstrike15UserMessages = exports.ECstrike15UserMessages || (exports.ECstrike15UserMessages = {}));
var ECSUsrMsgDisconnectToLobbyAction;
(function (ECSUsrMsgDisconnectToLobbyAction) {
    ECSUsrMsgDisconnectToLobbyAction[ECSUsrMsgDisconnectToLobbyAction["k_ECSUsrMsg_DisconnectToLobby_Action_Default"] = 0] = "k_ECSUsrMsg_DisconnectToLobby_Action_Default";
    ECSUsrMsgDisconnectToLobbyAction[ECSUsrMsgDisconnectToLobbyAction["k_ECSUsrMsg_DisconnectToLobby_Action_GoQueue"] = 1] = "k_ECSUsrMsg_DisconnectToLobby_Action_GoQueue";
})(ECSUsrMsgDisconnectToLobbyAction = exports.ECSUsrMsgDisconnectToLobbyAction || (exports.ECSUsrMsgDisconnectToLobbyAction = {}));
function createBaseCCSUsrMsgVGUIMenu() {
    return { name: "", show: false, subkeys: [] };
}
exports.CCSUsrMsgVGUIMenu = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.name !== "") {
            writer.uint32(10).string(message.name);
        }
        if (message.show === true) {
            writer.uint32(16).bool(message.show);
        }
        for (const v of message.subkeys) {
            exports.CCSUsrMsgVGUIMenu_Subkey.encode(v, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgVGUIMenu();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.name = reader.string();
                    break;
                case 2:
                    message.show = reader.bool();
                    break;
                case 3:
                    message.subkeys.push(exports.CCSUsrMsgVGUIMenu_Subkey.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCCSUsrMsgVGUIMenu();
        message.name = (_a = object.name) !== null && _a !== void 0 ? _a : "";
        message.show = (_b = object.show) !== null && _b !== void 0 ? _b : false;
        message.subkeys =
            ((_c = object.subkeys) === null || _c === void 0 ? void 0 : _c.map(e => exports.CCSUsrMsgVGUIMenu_Subkey.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCCSUsrMsgVGUIMenu_Subkey() {
    return { name: "", str: "" };
}
exports.CCSUsrMsgVGUIMenu_Subkey = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.name !== "") {
            writer.uint32(10).string(message.name);
        }
        if (message.str !== "") {
            writer.uint32(18).string(message.str);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgVGUIMenu_Subkey();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.name = reader.string();
                    break;
                case 2:
                    message.str = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCCSUsrMsgVGUIMenu_Subkey();
        message.name = (_a = object.name) !== null && _a !== void 0 ? _a : "";
        message.str = (_b = object.str) !== null && _b !== void 0 ? _b : "";
        return message;
    }
};
function createBaseCCSUsrMsgGeiger() {
    return { range: 0 };
}
exports.CCSUsrMsgGeiger = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.range !== 0) {
            writer.uint32(8).int32(message.range);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgGeiger();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.range = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgGeiger();
        message.range = (_a = object.range) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCCSUsrMsgTrain() {
    return { train: 0 };
}
exports.CCSUsrMsgTrain = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.train !== 0) {
            writer.uint32(8).int32(message.train);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgTrain();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.train = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgTrain();
        message.train = (_a = object.train) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCCSUsrMsgHudText() {
    return { text: "" };
}
exports.CCSUsrMsgHudText = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.text !== "") {
            writer.uint32(10).string(message.text);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgHudText();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.text = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgHudText();
        message.text = (_a = object.text) !== null && _a !== void 0 ? _a : "";
        return message;
    }
};
function createBaseCCSUsrMsgSayText() {
    return { entIdx: 0, text: "", chat: false, textallchat: false };
}
exports.CCSUsrMsgSayText = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.entIdx !== 0) {
            writer.uint32(8).int32(message.entIdx);
        }
        if (message.text !== "") {
            writer.uint32(18).string(message.text);
        }
        if (message.chat === true) {
            writer.uint32(24).bool(message.chat);
        }
        if (message.textallchat === true) {
            writer.uint32(32).bool(message.textallchat);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgSayText();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.entIdx = reader.int32();
                    break;
                case 2:
                    message.text = reader.string();
                    break;
                case 3:
                    message.chat = reader.bool();
                    break;
                case 4:
                    message.textallchat = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCSUsrMsgSayText();
        message.entIdx = (_a = object.entIdx) !== null && _a !== void 0 ? _a : 0;
        message.text = (_b = object.text) !== null && _b !== void 0 ? _b : "";
        message.chat = (_c = object.chat) !== null && _c !== void 0 ? _c : false;
        message.textallchat = (_d = object.textallchat) !== null && _d !== void 0 ? _d : false;
        return message;
    }
};
function createBaseCCSUsrMsgSayText2() {
    return {
        entIdx: 0,
        chat: false,
        msgName: "",
        params: [],
        textallchat: false
    };
}
exports.CCSUsrMsgSayText2 = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.entIdx !== 0) {
            writer.uint32(8).int32(message.entIdx);
        }
        if (message.chat === true) {
            writer.uint32(16).bool(message.chat);
        }
        if (message.msgName !== "") {
            writer.uint32(26).string(message.msgName);
        }
        for (const v of message.params) {
            writer.uint32(34).string(v);
        }
        if (message.textallchat === true) {
            writer.uint32(40).bool(message.textallchat);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgSayText2();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.entIdx = reader.int32();
                    break;
                case 2:
                    message.chat = reader.bool();
                    break;
                case 3:
                    message.msgName = reader.string();
                    break;
                case 4:
                    message.params.push(reader.string());
                    break;
                case 5:
                    message.textallchat = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseCCSUsrMsgSayText2();
        message.entIdx = (_a = object.entIdx) !== null && _a !== void 0 ? _a : 0;
        message.chat = (_b = object.chat) !== null && _b !== void 0 ? _b : false;
        message.msgName = (_c = object.msgName) !== null && _c !== void 0 ? _c : "";
        message.params = ((_d = object.params) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];
        message.textallchat = (_e = object.textallchat) !== null && _e !== void 0 ? _e : false;
        return message;
    }
};
function createBaseCCSUsrMsgTextMsg() {
    return { msgDst: 0, params: [] };
}
exports.CCSUsrMsgTextMsg = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.msgDst !== 0) {
            writer.uint32(8).int32(message.msgDst);
        }
        for (const v of message.params) {
            writer.uint32(26).string(v);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgTextMsg();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.msgDst = reader.int32();
                    break;
                case 3:
                    message.params.push(reader.string());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCCSUsrMsgTextMsg();
        message.msgDst = (_a = object.msgDst) !== null && _a !== void 0 ? _a : 0;
        message.params = ((_b = object.params) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];
        return message;
    }
};
function createBaseCCSUsrMsgHudMsg() {
    return {
        channel: 0,
        pos: undefined,
        clr1: undefined,
        clr2: undefined,
        effect: 0,
        fadeInTime: 0,
        fadeOutTime: 0,
        holdTime: 0,
        fxTime: 0,
        text: ""
    };
}
exports.CCSUsrMsgHudMsg = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.channel !== 0) {
            writer.uint32(8).int32(message.channel);
        }
        if (message.pos !== undefined) {
            netmessages_1.CMsgVector2D.encode(message.pos, writer.uint32(18).fork()).ldelim();
        }
        if (message.clr1 !== undefined) {
            netmessages_1.CMsgRGBA.encode(message.clr1, writer.uint32(26).fork()).ldelim();
        }
        if (message.clr2 !== undefined) {
            netmessages_1.CMsgRGBA.encode(message.clr2, writer.uint32(34).fork()).ldelim();
        }
        if (message.effect !== 0) {
            writer.uint32(40).int32(message.effect);
        }
        if (message.fadeInTime !== 0) {
            writer.uint32(53).float(message.fadeInTime);
        }
        if (message.fadeOutTime !== 0) {
            writer.uint32(61).float(message.fadeOutTime);
        }
        if (message.holdTime !== 0) {
            writer.uint32(77).float(message.holdTime);
        }
        if (message.fxTime !== 0) {
            writer.uint32(85).float(message.fxTime);
        }
        if (message.text !== "") {
            writer.uint32(90).string(message.text);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgHudMsg();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.channel = reader.int32();
                    break;
                case 2:
                    message.pos = netmessages_1.CMsgVector2D.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.clr1 = netmessages_1.CMsgRGBA.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.clr2 = netmessages_1.CMsgRGBA.decode(reader, reader.uint32());
                    break;
                case 5:
                    message.effect = reader.int32();
                    break;
                case 6:
                    message.fadeInTime = reader.float();
                    break;
                case 7:
                    message.fadeOutTime = reader.float();
                    break;
                case 9:
                    message.holdTime = reader.float();
                    break;
                case 10:
                    message.fxTime = reader.float();
                    break;
                case 11:
                    message.text = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g;
        const message = createBaseCCSUsrMsgHudMsg();
        message.channel = (_a = object.channel) !== null && _a !== void 0 ? _a : 0;
        message.pos =
            object.pos !== undefined && object.pos !== null
                ? netmessages_1.CMsgVector2D.fromPartial(object.pos)
                : undefined;
        message.clr1 =
            object.clr1 !== undefined && object.clr1 !== null
                ? netmessages_1.CMsgRGBA.fromPartial(object.clr1)
                : undefined;
        message.clr2 =
            object.clr2 !== undefined && object.clr2 !== null
                ? netmessages_1.CMsgRGBA.fromPartial(object.clr2)
                : undefined;
        message.effect = (_b = object.effect) !== null && _b !== void 0 ? _b : 0;
        message.fadeInTime = (_c = object.fadeInTime) !== null && _c !== void 0 ? _c : 0;
        message.fadeOutTime = (_d = object.fadeOutTime) !== null && _d !== void 0 ? _d : 0;
        message.holdTime = (_e = object.holdTime) !== null && _e !== void 0 ? _e : 0;
        message.fxTime = (_f = object.fxTime) !== null && _f !== void 0 ? _f : 0;
        message.text = (_g = object.text) !== null && _g !== void 0 ? _g : "";
        return message;
    }
};
function createBaseCCSUsrMsgShake() {
    return { command: 0, localAmplitude: 0, frequency: 0, duration: 0 };
}
exports.CCSUsrMsgShake = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.command !== 0) {
            writer.uint32(8).int32(message.command);
        }
        if (message.localAmplitude !== 0) {
            writer.uint32(21).float(message.localAmplitude);
        }
        if (message.frequency !== 0) {
            writer.uint32(29).float(message.frequency);
        }
        if (message.duration !== 0) {
            writer.uint32(37).float(message.duration);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgShake();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.command = reader.int32();
                    break;
                case 2:
                    message.localAmplitude = reader.float();
                    break;
                case 3:
                    message.frequency = reader.float();
                    break;
                case 4:
                    message.duration = reader.float();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCSUsrMsgShake();
        message.command = (_a = object.command) !== null && _a !== void 0 ? _a : 0;
        message.localAmplitude = (_b = object.localAmplitude) !== null && _b !== void 0 ? _b : 0;
        message.frequency = (_c = object.frequency) !== null && _c !== void 0 ? _c : 0;
        message.duration = (_d = object.duration) !== null && _d !== void 0 ? _d : 0;
        return message;
    }
};
function createBaseCCSUsrMsgFade() {
    return { duration: 0, holdTime: 0, flags: 0, clr: undefined };
}
exports.CCSUsrMsgFade = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.duration !== 0) {
            writer.uint32(8).int32(message.duration);
        }
        if (message.holdTime !== 0) {
            writer.uint32(16).int32(message.holdTime);
        }
        if (message.flags !== 0) {
            writer.uint32(24).int32(message.flags);
        }
        if (message.clr !== undefined) {
            netmessages_1.CMsgRGBA.encode(message.clr, writer.uint32(34).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgFade();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.duration = reader.int32();
                    break;
                case 2:
                    message.holdTime = reader.int32();
                    break;
                case 3:
                    message.flags = reader.int32();
                    break;
                case 4:
                    message.clr = netmessages_1.CMsgRGBA.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCCSUsrMsgFade();
        message.duration = (_a = object.duration) !== null && _a !== void 0 ? _a : 0;
        message.holdTime = (_b = object.holdTime) !== null && _b !== void 0 ? _b : 0;
        message.flags = (_c = object.flags) !== null && _c !== void 0 ? _c : 0;
        message.clr =
            object.clr !== undefined && object.clr !== null
                ? netmessages_1.CMsgRGBA.fromPartial(object.clr)
                : undefined;
        return message;
    }
};
function createBaseCCSUsrMsgRumble() {
    return { index: 0, data: 0, flags: 0 };
}
exports.CCSUsrMsgRumble = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.index !== 0) {
            writer.uint32(8).int32(message.index);
        }
        if (message.data !== 0) {
            writer.uint32(16).int32(message.data);
        }
        if (message.flags !== 0) {
            writer.uint32(24).int32(message.flags);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgRumble();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.index = reader.int32();
                    break;
                case 2:
                    message.data = reader.int32();
                    break;
                case 3:
                    message.flags = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCCSUsrMsgRumble();
        message.index = (_a = object.index) !== null && _a !== void 0 ? _a : 0;
        message.data = (_b = object.data) !== null && _b !== void 0 ? _b : 0;
        message.flags = (_c = object.flags) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseCCSUsrMsgCloseCaption() {
    return { hash: 0, duration: 0, fromPlayer: false, cctoken: "" };
}
exports.CCSUsrMsgCloseCaption = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.hash !== 0) {
            writer.uint32(8).uint32(message.hash);
        }
        if (message.duration !== 0) {
            writer.uint32(16).int32(message.duration);
        }
        if (message.fromPlayer === true) {
            writer.uint32(24).bool(message.fromPlayer);
        }
        if (message.cctoken !== "") {
            writer.uint32(34).string(message.cctoken);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgCloseCaption();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.hash = reader.uint32();
                    break;
                case 2:
                    message.duration = reader.int32();
                    break;
                case 3:
                    message.fromPlayer = reader.bool();
                    break;
                case 4:
                    message.cctoken = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCSUsrMsgCloseCaption();
        message.hash = (_a = object.hash) !== null && _a !== void 0 ? _a : 0;
        message.duration = (_b = object.duration) !== null && _b !== void 0 ? _b : 0;
        message.fromPlayer = (_c = object.fromPlayer) !== null && _c !== void 0 ? _c : false;
        message.cctoken = (_d = object.cctoken) !== null && _d !== void 0 ? _d : "";
        return message;
    }
};
function createBaseCCSUsrMsgCloseCaptionDirect() {
    return { hash: 0, duration: 0, fromPlayer: false };
}
exports.CCSUsrMsgCloseCaptionDirect = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.hash !== 0) {
            writer.uint32(8).uint32(message.hash);
        }
        if (message.duration !== 0) {
            writer.uint32(16).int32(message.duration);
        }
        if (message.fromPlayer === true) {
            writer.uint32(24).bool(message.fromPlayer);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgCloseCaptionDirect();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.hash = reader.uint32();
                    break;
                case 2:
                    message.duration = reader.int32();
                    break;
                case 3:
                    message.fromPlayer = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCCSUsrMsgCloseCaptionDirect();
        message.hash = (_a = object.hash) !== null && _a !== void 0 ? _a : 0;
        message.duration = (_b = object.duration) !== null && _b !== void 0 ? _b : 0;
        message.fromPlayer = (_c = object.fromPlayer) !== null && _c !== void 0 ? _c : false;
        return message;
    }
};
function createBaseCCSUsrMsgSendAudio() {
    return { radioSound: "" };
}
exports.CCSUsrMsgSendAudio = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.radioSound !== "") {
            writer.uint32(10).string(message.radioSound);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgSendAudio();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.radioSound = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgSendAudio();
        message.radioSound = (_a = object.radioSound) !== null && _a !== void 0 ? _a : "";
        return message;
    }
};
function createBaseCCSUsrMsgRawAudio() {
    return { pitch: 0, entidx: 0, duration: 0, voiceFilename: "" };
}
exports.CCSUsrMsgRawAudio = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.pitch !== 0) {
            writer.uint32(8).int32(message.pitch);
        }
        if (message.entidx !== 0) {
            writer.uint32(16).int32(message.entidx);
        }
        if (message.duration !== 0) {
            writer.uint32(29).float(message.duration);
        }
        if (message.voiceFilename !== "") {
            writer.uint32(34).string(message.voiceFilename);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgRawAudio();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.pitch = reader.int32();
                    break;
                case 2:
                    message.entidx = reader.int32();
                    break;
                case 3:
                    message.duration = reader.float();
                    break;
                case 4:
                    message.voiceFilename = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCSUsrMsgRawAudio();
        message.pitch = (_a = object.pitch) !== null && _a !== void 0 ? _a : 0;
        message.entidx = (_b = object.entidx) !== null && _b !== void 0 ? _b : 0;
        message.duration = (_c = object.duration) !== null && _c !== void 0 ? _c : 0;
        message.voiceFilename = (_d = object.voiceFilename) !== null && _d !== void 0 ? _d : "";
        return message;
    }
};
function createBaseCCSUsrMsgVoiceMask() {
    return { playerMasks: [], playerModEnable: false };
}
exports.CCSUsrMsgVoiceMask = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.playerMasks) {
            exports.CCSUsrMsgVoiceMask_PlayerMask.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.playerModEnable === true) {
            writer.uint32(16).bool(message.playerModEnable);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgVoiceMask();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.playerMasks.push(exports.CCSUsrMsgVoiceMask_PlayerMask.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.playerModEnable = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCCSUsrMsgVoiceMask();
        message.playerMasks =
            ((_a = object.playerMasks) === null || _a === void 0 ? void 0 : _a.map(e => exports.CCSUsrMsgVoiceMask_PlayerMask.fromPartial(e))) || [];
        message.playerModEnable = (_b = object.playerModEnable) !== null && _b !== void 0 ? _b : false;
        return message;
    }
};
function createBaseCCSUsrMsgVoiceMask_PlayerMask() {
    return { gameRulesMask: 0, banMasks: 0 };
}
exports.CCSUsrMsgVoiceMask_PlayerMask = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.gameRulesMask !== 0) {
            writer.uint32(8).int32(message.gameRulesMask);
        }
        if (message.banMasks !== 0) {
            writer.uint32(16).int32(message.banMasks);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgVoiceMask_PlayerMask();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.gameRulesMask = reader.int32();
                    break;
                case 2:
                    message.banMasks = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCCSUsrMsgVoiceMask_PlayerMask();
        message.gameRulesMask = (_a = object.gameRulesMask) !== null && _a !== void 0 ? _a : 0;
        message.banMasks = (_b = object.banMasks) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCCSUsrMsgDamage() {
    return { amount: 0, inflictorWorldPos: undefined, victimEntindex: 0 };
}
exports.CCSUsrMsgDamage = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.amount !== 0) {
            writer.uint32(8).int32(message.amount);
        }
        if (message.inflictorWorldPos !== undefined) {
            netmessages_1.CMsgVector.encode(message.inflictorWorldPos, writer.uint32(18).fork()).ldelim();
        }
        if (message.victimEntindex !== 0) {
            writer.uint32(24).int32(message.victimEntindex);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgDamage();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.amount = reader.int32();
                    break;
                case 2:
                    message.inflictorWorldPos = netmessages_1.CMsgVector.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.victimEntindex = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCCSUsrMsgDamage();
        message.amount = (_a = object.amount) !== null && _a !== void 0 ? _a : 0;
        message.inflictorWorldPos =
            object.inflictorWorldPos !== undefined &&
                object.inflictorWorldPos !== null
                ? netmessages_1.CMsgVector.fromPartial(object.inflictorWorldPos)
                : undefined;
        message.victimEntindex = (_b = object.victimEntindex) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCCSUsrMsgRadioText() {
    return { msgDst: 0, client: 0, msgName: "", params: [] };
}
exports.CCSUsrMsgRadioText = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.msgDst !== 0) {
            writer.uint32(8).int32(message.msgDst);
        }
        if (message.client !== 0) {
            writer.uint32(16).int32(message.client);
        }
        if (message.msgName !== "") {
            writer.uint32(26).string(message.msgName);
        }
        for (const v of message.params) {
            writer.uint32(34).string(v);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgRadioText();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.msgDst = reader.int32();
                    break;
                case 2:
                    message.client = reader.int32();
                    break;
                case 3:
                    message.msgName = reader.string();
                    break;
                case 4:
                    message.params.push(reader.string());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCSUsrMsgRadioText();
        message.msgDst = (_a = object.msgDst) !== null && _a !== void 0 ? _a : 0;
        message.client = (_b = object.client) !== null && _b !== void 0 ? _b : 0;
        message.msgName = (_c = object.msgName) !== null && _c !== void 0 ? _c : "";
        message.params = ((_d = object.params) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];
        return message;
    }
};
function createBaseCCSUsrMsgHintText() {
    return { text: "" };
}
exports.CCSUsrMsgHintText = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.text !== "") {
            writer.uint32(10).string(message.text);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgHintText();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.text = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgHintText();
        message.text = (_a = object.text) !== null && _a !== void 0 ? _a : "";
        return message;
    }
};
function createBaseCCSUsrMsgKeyHintText() {
    return { hints: [] };
}
exports.CCSUsrMsgKeyHintText = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.hints) {
            writer.uint32(10).string(v);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgKeyHintText();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.hints.push(reader.string());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgKeyHintText();
        message.hints = ((_a = object.hints) === null || _a === void 0 ? void 0 : _a.map(e => e)) || [];
        return message;
    }
};
function createBaseCCSUsrMsgProcessSpottedEntityUpdate() {
    return { newUpdate: false, entityUpdates: [] };
}
exports.CCSUsrMsgProcessSpottedEntityUpdate = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.newUpdate === true) {
            writer.uint32(8).bool(message.newUpdate);
        }
        for (const v of message.entityUpdates) {
            exports.CCSUsrMsgProcessSpottedEntityUpdate_SpottedEntityUpdate.encode(v, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgProcessSpottedEntityUpdate();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.newUpdate = reader.bool();
                    break;
                case 2:
                    message.entityUpdates.push(exports.CCSUsrMsgProcessSpottedEntityUpdate_SpottedEntityUpdate.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCCSUsrMsgProcessSpottedEntityUpdate();
        message.newUpdate = (_a = object.newUpdate) !== null && _a !== void 0 ? _a : false;
        message.entityUpdates =
            ((_b = object.entityUpdates) === null || _b === void 0 ? void 0 : _b.map(e => exports.CCSUsrMsgProcessSpottedEntityUpdate_SpottedEntityUpdate.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCCSUsrMsgProcessSpottedEntityUpdate_SpottedEntityUpdate() {
    return {
        entityIdx: 0,
        classId: 0,
        originX: 0,
        originY: 0,
        originZ: 0,
        angleY: 0,
        defuser: false,
        playerHasDefuser: false,
        playerHasC4: false
    };
}
exports.CCSUsrMsgProcessSpottedEntityUpdate_SpottedEntityUpdate = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.entityIdx !== 0) {
            writer.uint32(8).int32(message.entityIdx);
        }
        if (message.classId !== 0) {
            writer.uint32(16).int32(message.classId);
        }
        if (message.originX !== 0) {
            writer.uint32(24).int32(message.originX);
        }
        if (message.originY !== 0) {
            writer.uint32(32).int32(message.originY);
        }
        if (message.originZ !== 0) {
            writer.uint32(40).int32(message.originZ);
        }
        if (message.angleY !== 0) {
            writer.uint32(48).int32(message.angleY);
        }
        if (message.defuser === true) {
            writer.uint32(56).bool(message.defuser);
        }
        if (message.playerHasDefuser === true) {
            writer.uint32(64).bool(message.playerHasDefuser);
        }
        if (message.playerHasC4 === true) {
            writer.uint32(72).bool(message.playerHasC4);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgProcessSpottedEntityUpdate_SpottedEntityUpdate();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.entityIdx = reader.int32();
                    break;
                case 2:
                    message.classId = reader.int32();
                    break;
                case 3:
                    message.originX = reader.int32();
                    break;
                case 4:
                    message.originY = reader.int32();
                    break;
                case 5:
                    message.originZ = reader.int32();
                    break;
                case 6:
                    message.angleY = reader.int32();
                    break;
                case 7:
                    message.defuser = reader.bool();
                    break;
                case 8:
                    message.playerHasDefuser = reader.bool();
                    break;
                case 9:
                    message.playerHasC4 = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
        const message = createBaseCCSUsrMsgProcessSpottedEntityUpdate_SpottedEntityUpdate();
        message.entityIdx = (_a = object.entityIdx) !== null && _a !== void 0 ? _a : 0;
        message.classId = (_b = object.classId) !== null && _b !== void 0 ? _b : 0;
        message.originX = (_c = object.originX) !== null && _c !== void 0 ? _c : 0;
        message.originY = (_d = object.originY) !== null && _d !== void 0 ? _d : 0;
        message.originZ = (_e = object.originZ) !== null && _e !== void 0 ? _e : 0;
        message.angleY = (_f = object.angleY) !== null && _f !== void 0 ? _f : 0;
        message.defuser = (_g = object.defuser) !== null && _g !== void 0 ? _g : false;
        message.playerHasDefuser = (_h = object.playerHasDefuser) !== null && _h !== void 0 ? _h : false;
        message.playerHasC4 = (_j = object.playerHasC4) !== null && _j !== void 0 ? _j : false;
        return message;
    }
};
function createBaseCCSUsrMsgSendPlayerItemDrops() {
    return { entityUpdates: [] };
}
exports.CCSUsrMsgSendPlayerItemDrops = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.entityUpdates) {
            cstrike15_gcmessages_1.CEconItemPreviewDataBlock.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgSendPlayerItemDrops();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.entityUpdates.push(cstrike15_gcmessages_1.CEconItemPreviewDataBlock.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgSendPlayerItemDrops();
        message.entityUpdates =
            ((_a = object.entityUpdates) === null || _a === void 0 ? void 0 : _a.map(e => cstrike15_gcmessages_1.CEconItemPreviewDataBlock.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCCSUsrMsgSendPlayerItemFound() {
    return { iteminfo: undefined, entindex: 0 };
}
exports.CCSUsrMsgSendPlayerItemFound = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.iteminfo !== undefined) {
            cstrike15_gcmessages_1.CEconItemPreviewDataBlock.encode(message.iteminfo, writer.uint32(10).fork()).ldelim();
        }
        if (message.entindex !== 0) {
            writer.uint32(16).int32(message.entindex);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgSendPlayerItemFound();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.iteminfo = cstrike15_gcmessages_1.CEconItemPreviewDataBlock.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.entindex = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgSendPlayerItemFound();
        message.iteminfo =
            object.iteminfo !== undefined && object.iteminfo !== null
                ? cstrike15_gcmessages_1.CEconItemPreviewDataBlock.fromPartial(object.iteminfo)
                : undefined;
        message.entindex = (_a = object.entindex) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCCSUsrMsgReloadEffect() {
    return { entidx: 0, actanim: 0, originX: 0, originY: 0, originZ: 0 };
}
exports.CCSUsrMsgReloadEffect = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.entidx !== 0) {
            writer.uint32(8).int32(message.entidx);
        }
        if (message.actanim !== 0) {
            writer.uint32(16).int32(message.actanim);
        }
        if (message.originX !== 0) {
            writer.uint32(29).float(message.originX);
        }
        if (message.originY !== 0) {
            writer.uint32(37).float(message.originY);
        }
        if (message.originZ !== 0) {
            writer.uint32(45).float(message.originZ);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgReloadEffect();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.entidx = reader.int32();
                    break;
                case 2:
                    message.actanim = reader.int32();
                    break;
                case 3:
                    message.originX = reader.float();
                    break;
                case 4:
                    message.originY = reader.float();
                    break;
                case 5:
                    message.originZ = reader.float();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseCCSUsrMsgReloadEffect();
        message.entidx = (_a = object.entidx) !== null && _a !== void 0 ? _a : 0;
        message.actanim = (_b = object.actanim) !== null && _b !== void 0 ? _b : 0;
        message.originX = (_c = object.originX) !== null && _c !== void 0 ? _c : 0;
        message.originY = (_d = object.originY) !== null && _d !== void 0 ? _d : 0;
        message.originZ = (_e = object.originZ) !== null && _e !== void 0 ? _e : 0;
        return message;
    }
};
function createBaseCCSUsrMsgWeaponSound() {
    return {
        entidx: 0,
        originX: 0,
        originY: 0,
        originZ: 0,
        sound: "",
        timestamp: 0
    };
}
exports.CCSUsrMsgWeaponSound = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.entidx !== 0) {
            writer.uint32(8).int32(message.entidx);
        }
        if (message.originX !== 0) {
            writer.uint32(21).float(message.originX);
        }
        if (message.originY !== 0) {
            writer.uint32(29).float(message.originY);
        }
        if (message.originZ !== 0) {
            writer.uint32(37).float(message.originZ);
        }
        if (message.sound !== "") {
            writer.uint32(42).string(message.sound);
        }
        if (message.timestamp !== 0) {
            writer.uint32(53).float(message.timestamp);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgWeaponSound();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.entidx = reader.int32();
                    break;
                case 2:
                    message.originX = reader.float();
                    break;
                case 3:
                    message.originY = reader.float();
                    break;
                case 4:
                    message.originZ = reader.float();
                    break;
                case 5:
                    message.sound = reader.string();
                    break;
                case 6:
                    message.timestamp = reader.float();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f;
        const message = createBaseCCSUsrMsgWeaponSound();
        message.entidx = (_a = object.entidx) !== null && _a !== void 0 ? _a : 0;
        message.originX = (_b = object.originX) !== null && _b !== void 0 ? _b : 0;
        message.originY = (_c = object.originY) !== null && _c !== void 0 ? _c : 0;
        message.originZ = (_d = object.originZ) !== null && _d !== void 0 ? _d : 0;
        message.sound = (_e = object.sound) !== null && _e !== void 0 ? _e : "";
        message.timestamp = (_f = object.timestamp) !== null && _f !== void 0 ? _f : 0;
        return message;
    }
};
function createBaseCCSUsrMsgUpdateScreenHealthBar() {
    return { entidx: 0, healthratioOld: 0, healthratioNew: 0, style: 0 };
}
exports.CCSUsrMsgUpdateScreenHealthBar = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.entidx !== 0) {
            writer.uint32(8).int32(message.entidx);
        }
        if (message.healthratioOld !== 0) {
            writer.uint32(21).float(message.healthratioOld);
        }
        if (message.healthratioNew !== 0) {
            writer.uint32(29).float(message.healthratioNew);
        }
        if (message.style !== 0) {
            writer.uint32(32).int32(message.style);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgUpdateScreenHealthBar();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.entidx = reader.int32();
                    break;
                case 2:
                    message.healthratioOld = reader.float();
                    break;
                case 3:
                    message.healthratioNew = reader.float();
                    break;
                case 4:
                    message.style = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCSUsrMsgUpdateScreenHealthBar();
        message.entidx = (_a = object.entidx) !== null && _a !== void 0 ? _a : 0;
        message.healthratioOld = (_b = object.healthratioOld) !== null && _b !== void 0 ? _b : 0;
        message.healthratioNew = (_c = object.healthratioNew) !== null && _c !== void 0 ? _c : 0;
        message.style = (_d = object.style) !== null && _d !== void 0 ? _d : 0;
        return message;
    }
};
function createBaseCCSUsrMsgEntityOutlineHighlight() {
    return { entidx: 0, removehighlight: false };
}
exports.CCSUsrMsgEntityOutlineHighlight = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.entidx !== 0) {
            writer.uint32(8).int32(message.entidx);
        }
        if (message.removehighlight === true) {
            writer.uint32(16).bool(message.removehighlight);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgEntityOutlineHighlight();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.entidx = reader.int32();
                    break;
                case 2:
                    message.removehighlight = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCCSUsrMsgEntityOutlineHighlight();
        message.entidx = (_a = object.entidx) !== null && _a !== void 0 ? _a : 0;
        message.removehighlight = (_b = object.removehighlight) !== null && _b !== void 0 ? _b : false;
        return message;
    }
};
function createBaseCCSUsrMsgAdjustMoney() {
    return { amount: 0 };
}
exports.CCSUsrMsgAdjustMoney = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.amount !== 0) {
            writer.uint32(8).int32(message.amount);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgAdjustMoney();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.amount = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgAdjustMoney();
        message.amount = (_a = object.amount) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCCSUsrMsgReportHit() {
    return { posX: 0, posY: 0, timestamp: 0, posZ: 0 };
}
exports.CCSUsrMsgReportHit = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.posX !== 0) {
            writer.uint32(13).float(message.posX);
        }
        if (message.posY !== 0) {
            writer.uint32(21).float(message.posY);
        }
        if (message.timestamp !== 0) {
            writer.uint32(37).float(message.timestamp);
        }
        if (message.posZ !== 0) {
            writer.uint32(29).float(message.posZ);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgReportHit();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.posX = reader.float();
                    break;
                case 2:
                    message.posY = reader.float();
                    break;
                case 4:
                    message.timestamp = reader.float();
                    break;
                case 3:
                    message.posZ = reader.float();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCSUsrMsgReportHit();
        message.posX = (_a = object.posX) !== null && _a !== void 0 ? _a : 0;
        message.posY = (_b = object.posY) !== null && _b !== void 0 ? _b : 0;
        message.timestamp = (_c = object.timestamp) !== null && _c !== void 0 ? _c : 0;
        message.posZ = (_d = object.posZ) !== null && _d !== void 0 ? _d : 0;
        return message;
    }
};
function createBaseCCSUsrMsgKillCam() {
    return { obsMode: 0, firstTarget: 0, secondTarget: 0 };
}
exports.CCSUsrMsgKillCam = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.obsMode !== 0) {
            writer.uint32(8).int32(message.obsMode);
        }
        if (message.firstTarget !== 0) {
            writer.uint32(16).int32(message.firstTarget);
        }
        if (message.secondTarget !== 0) {
            writer.uint32(24).int32(message.secondTarget);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgKillCam();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.obsMode = reader.int32();
                    break;
                case 2:
                    message.firstTarget = reader.int32();
                    break;
                case 3:
                    message.secondTarget = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCCSUsrMsgKillCam();
        message.obsMode = (_a = object.obsMode) !== null && _a !== void 0 ? _a : 0;
        message.firstTarget = (_b = object.firstTarget) !== null && _b !== void 0 ? _b : 0;
        message.secondTarget = (_c = object.secondTarget) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseCCSUsrMsgDesiredTimescale() {
    return {
        desiredTimescale: 0,
        durationRealtimeSec: 0,
        interpolatorType: 0,
        startBlendTime: 0
    };
}
exports.CCSUsrMsgDesiredTimescale = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.desiredTimescale !== 0) {
            writer.uint32(13).float(message.desiredTimescale);
        }
        if (message.durationRealtimeSec !== 0) {
            writer.uint32(21).float(message.durationRealtimeSec);
        }
        if (message.interpolatorType !== 0) {
            writer.uint32(24).int32(message.interpolatorType);
        }
        if (message.startBlendTime !== 0) {
            writer.uint32(37).float(message.startBlendTime);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgDesiredTimescale();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.desiredTimescale = reader.float();
                    break;
                case 2:
                    message.durationRealtimeSec = reader.float();
                    break;
                case 3:
                    message.interpolatorType = reader.int32();
                    break;
                case 4:
                    message.startBlendTime = reader.float();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCSUsrMsgDesiredTimescale();
        message.desiredTimescale = (_a = object.desiredTimescale) !== null && _a !== void 0 ? _a : 0;
        message.durationRealtimeSec = (_b = object.durationRealtimeSec) !== null && _b !== void 0 ? _b : 0;
        message.interpolatorType = (_c = object.interpolatorType) !== null && _c !== void 0 ? _c : 0;
        message.startBlendTime = (_d = object.startBlendTime) !== null && _d !== void 0 ? _d : 0;
        return message;
    }
};
function createBaseCCSUsrMsgCurrentTimescale() {
    return { curTimescale: 0 };
}
exports.CCSUsrMsgCurrentTimescale = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.curTimescale !== 0) {
            writer.uint32(13).float(message.curTimescale);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgCurrentTimescale();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.curTimescale = reader.float();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgCurrentTimescale();
        message.curTimescale = (_a = object.curTimescale) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCCSUsrMsgAchievementEvent() {
    return { achievement: 0, count: 0, userId: 0 };
}
exports.CCSUsrMsgAchievementEvent = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.achievement !== 0) {
            writer.uint32(8).int32(message.achievement);
        }
        if (message.count !== 0) {
            writer.uint32(16).int32(message.count);
        }
        if (message.userId !== 0) {
            writer.uint32(24).int32(message.userId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgAchievementEvent();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.achievement = reader.int32();
                    break;
                case 2:
                    message.count = reader.int32();
                    break;
                case 3:
                    message.userId = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCCSUsrMsgAchievementEvent();
        message.achievement = (_a = object.achievement) !== null && _a !== void 0 ? _a : 0;
        message.count = (_b = object.count) !== null && _b !== void 0 ? _b : 0;
        message.userId = (_c = object.userId) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseCCSUsrMsgMatchEndConditions() {
    return { fraglimit: 0, mpMaxrounds: 0, mpWinlimit: 0, mpTimelimit: 0 };
}
exports.CCSUsrMsgMatchEndConditions = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.fraglimit !== 0) {
            writer.uint32(8).int32(message.fraglimit);
        }
        if (message.mpMaxrounds !== 0) {
            writer.uint32(16).int32(message.mpMaxrounds);
        }
        if (message.mpWinlimit !== 0) {
            writer.uint32(24).int32(message.mpWinlimit);
        }
        if (message.mpTimelimit !== 0) {
            writer.uint32(32).int32(message.mpTimelimit);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgMatchEndConditions();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.fraglimit = reader.int32();
                    break;
                case 2:
                    message.mpMaxrounds = reader.int32();
                    break;
                case 3:
                    message.mpWinlimit = reader.int32();
                    break;
                case 4:
                    message.mpTimelimit = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCSUsrMsgMatchEndConditions();
        message.fraglimit = (_a = object.fraglimit) !== null && _a !== void 0 ? _a : 0;
        message.mpMaxrounds = (_b = object.mpMaxrounds) !== null && _b !== void 0 ? _b : 0;
        message.mpWinlimit = (_c = object.mpWinlimit) !== null && _c !== void 0 ? _c : 0;
        message.mpTimelimit = (_d = object.mpTimelimit) !== null && _d !== void 0 ? _d : 0;
        return message;
    }
};
function createBaseCCSUsrMsgPlayerStatsUpdate() {
    return { version: 0, stats: [], userId: 0, crc: 0 };
}
exports.CCSUsrMsgPlayerStatsUpdate = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.version !== 0) {
            writer.uint32(8).int32(message.version);
        }
        for (const v of message.stats) {
            exports.CCSUsrMsgPlayerStatsUpdate_Stat.encode(v, writer.uint32(34).fork()).ldelim();
        }
        if (message.userId !== 0) {
            writer.uint32(40).int32(message.userId);
        }
        if (message.crc !== 0) {
            writer.uint32(48).int32(message.crc);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgPlayerStatsUpdate();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.version = reader.int32();
                    break;
                case 4:
                    message.stats.push(exports.CCSUsrMsgPlayerStatsUpdate_Stat.decode(reader, reader.uint32()));
                    break;
                case 5:
                    message.userId = reader.int32();
                    break;
                case 6:
                    message.crc = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCSUsrMsgPlayerStatsUpdate();
        message.version = (_a = object.version) !== null && _a !== void 0 ? _a : 0;
        message.stats =
            ((_b = object.stats) === null || _b === void 0 ? void 0 : _b.map(e => exports.CCSUsrMsgPlayerStatsUpdate_Stat.fromPartial(e))) ||
                [];
        message.userId = (_c = object.userId) !== null && _c !== void 0 ? _c : 0;
        message.crc = (_d = object.crc) !== null && _d !== void 0 ? _d : 0;
        return message;
    }
};
function createBaseCCSUsrMsgPlayerStatsUpdate_Stat() {
    return { idx: 0, delta: 0 };
}
exports.CCSUsrMsgPlayerStatsUpdate_Stat = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.idx !== 0) {
            writer.uint32(8).int32(message.idx);
        }
        if (message.delta !== 0) {
            writer.uint32(16).int32(message.delta);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgPlayerStatsUpdate_Stat();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.idx = reader.int32();
                    break;
                case 2:
                    message.delta = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCCSUsrMsgPlayerStatsUpdate_Stat();
        message.idx = (_a = object.idx) !== null && _a !== void 0 ? _a : 0;
        message.delta = (_b = object.delta) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCCSUsrMsgDisplayInventory() {
    return { display: false, userId: 0 };
}
exports.CCSUsrMsgDisplayInventory = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.display === true) {
            writer.uint32(8).bool(message.display);
        }
        if (message.userId !== 0) {
            writer.uint32(16).int32(message.userId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgDisplayInventory();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.display = reader.bool();
                    break;
                case 2:
                    message.userId = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCCSUsrMsgDisplayInventory();
        message.display = (_a = object.display) !== null && _a !== void 0 ? _a : false;
        message.userId = (_b = object.userId) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCCSUsrMsgQuestProgress() {
    return { questId: 0, normalPoints: 0, bonusPoints: 0, isEventQuest: false };
}
exports.CCSUsrMsgQuestProgress = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.questId !== 0) {
            writer.uint32(8).uint32(message.questId);
        }
        if (message.normalPoints !== 0) {
            writer.uint32(16).uint32(message.normalPoints);
        }
        if (message.bonusPoints !== 0) {
            writer.uint32(24).uint32(message.bonusPoints);
        }
        if (message.isEventQuest === true) {
            writer.uint32(32).bool(message.isEventQuest);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgQuestProgress();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.questId = reader.uint32();
                    break;
                case 2:
                    message.normalPoints = reader.uint32();
                    break;
                case 3:
                    message.bonusPoints = reader.uint32();
                    break;
                case 4:
                    message.isEventQuest = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCSUsrMsgQuestProgress();
        message.questId = (_a = object.questId) !== null && _a !== void 0 ? _a : 0;
        message.normalPoints = (_b = object.normalPoints) !== null && _b !== void 0 ? _b : 0;
        message.bonusPoints = (_c = object.bonusPoints) !== null && _c !== void 0 ? _c : 0;
        message.isEventQuest = (_d = object.isEventQuest) !== null && _d !== void 0 ? _d : false;
        return message;
    }
};
function createBaseCCSUsrMsgScoreLeaderboardData() {
    return { data: undefined };
}
exports.CCSUsrMsgScoreLeaderboardData = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.data !== undefined) {
            cstrike15_gcmessages_1.ScoreLeaderboardData.encode(message.data, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgScoreLeaderboardData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.data = cstrike15_gcmessages_1.ScoreLeaderboardData.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCCSUsrMsgScoreLeaderboardData();
        message.data =
            object.data !== undefined && object.data !== null
                ? cstrike15_gcmessages_1.ScoreLeaderboardData.fromPartial(object.data)
                : undefined;
        return message;
    }
};
function createBaseCCSUsrMsgPlayerDecalDigitalSignature() {
    return { data: undefined };
}
exports.CCSUsrMsgPlayerDecalDigitalSignature = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.data !== undefined) {
            cstrike15_gcmessages_1.PlayerDecalDigitalSignature.encode(message.data, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgPlayerDecalDigitalSignature();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.data = cstrike15_gcmessages_1.PlayerDecalDigitalSignature.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCCSUsrMsgPlayerDecalDigitalSignature();
        message.data =
            object.data !== undefined && object.data !== null
                ? cstrike15_gcmessages_1.PlayerDecalDigitalSignature.fromPartial(object.data)
                : undefined;
        return message;
    }
};
function createBaseCCSUsrMsgXRankGet() {
    return { modeIdx: 0, controller: 0 };
}
exports.CCSUsrMsgXRankGet = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.modeIdx !== 0) {
            writer.uint32(8).int32(message.modeIdx);
        }
        if (message.controller !== 0) {
            writer.uint32(16).int32(message.controller);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgXRankGet();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.modeIdx = reader.int32();
                    break;
                case 2:
                    message.controller = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCCSUsrMsgXRankGet();
        message.modeIdx = (_a = object.modeIdx) !== null && _a !== void 0 ? _a : 0;
        message.controller = (_b = object.controller) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCCSUsrMsgXRankUpd() {
    return { modeIdx: 0, controller: 0, ranking: 0 };
}
exports.CCSUsrMsgXRankUpd = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.modeIdx !== 0) {
            writer.uint32(8).int32(message.modeIdx);
        }
        if (message.controller !== 0) {
            writer.uint32(16).int32(message.controller);
        }
        if (message.ranking !== 0) {
            writer.uint32(24).int32(message.ranking);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgXRankUpd();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.modeIdx = reader.int32();
                    break;
                case 2:
                    message.controller = reader.int32();
                    break;
                case 3:
                    message.ranking = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCCSUsrMsgXRankUpd();
        message.modeIdx = (_a = object.modeIdx) !== null && _a !== void 0 ? _a : 0;
        message.controller = (_b = object.controller) !== null && _b !== void 0 ? _b : 0;
        message.ranking = (_c = object.ranking) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseCCSUsrMsgCallVoteFailed() {
    return { reason: 0, time: 0 };
}
exports.CCSUsrMsgCallVoteFailed = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.reason !== 0) {
            writer.uint32(8).int32(message.reason);
        }
        if (message.time !== 0) {
            writer.uint32(16).int32(message.time);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgCallVoteFailed();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.reason = reader.int32();
                    break;
                case 2:
                    message.time = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCCSUsrMsgCallVoteFailed();
        message.reason = (_a = object.reason) !== null && _a !== void 0 ? _a : 0;
        message.time = (_b = object.time) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCCSUsrMsgVoteStart() {
    return {
        team: 0,
        entIdx: 0,
        voteType: 0,
        dispStr: "",
        detailsStr: "",
        otherTeamStr: "",
        isYesNoVote: false,
        entidxTarget: 0
    };
}
exports.CCSUsrMsgVoteStart = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.team !== 0) {
            writer.uint32(8).int32(message.team);
        }
        if (message.entIdx !== 0) {
            writer.uint32(16).int32(message.entIdx);
        }
        if (message.voteType !== 0) {
            writer.uint32(24).int32(message.voteType);
        }
        if (message.dispStr !== "") {
            writer.uint32(34).string(message.dispStr);
        }
        if (message.detailsStr !== "") {
            writer.uint32(42).string(message.detailsStr);
        }
        if (message.otherTeamStr !== "") {
            writer.uint32(50).string(message.otherTeamStr);
        }
        if (message.isYesNoVote === true) {
            writer.uint32(56).bool(message.isYesNoVote);
        }
        if (message.entidxTarget !== 0) {
            writer.uint32(64).int32(message.entidxTarget);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgVoteStart();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.team = reader.int32();
                    break;
                case 2:
                    message.entIdx = reader.int32();
                    break;
                case 3:
                    message.voteType = reader.int32();
                    break;
                case 4:
                    message.dispStr = reader.string();
                    break;
                case 5:
                    message.detailsStr = reader.string();
                    break;
                case 6:
                    message.otherTeamStr = reader.string();
                    break;
                case 7:
                    message.isYesNoVote = reader.bool();
                    break;
                case 8:
                    message.entidxTarget = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h;
        const message = createBaseCCSUsrMsgVoteStart();
        message.team = (_a = object.team) !== null && _a !== void 0 ? _a : 0;
        message.entIdx = (_b = object.entIdx) !== null && _b !== void 0 ? _b : 0;
        message.voteType = (_c = object.voteType) !== null && _c !== void 0 ? _c : 0;
        message.dispStr = (_d = object.dispStr) !== null && _d !== void 0 ? _d : "";
        message.detailsStr = (_e = object.detailsStr) !== null && _e !== void 0 ? _e : "";
        message.otherTeamStr = (_f = object.otherTeamStr) !== null && _f !== void 0 ? _f : "";
        message.isYesNoVote = (_g = object.isYesNoVote) !== null && _g !== void 0 ? _g : false;
        message.entidxTarget = (_h = object.entidxTarget) !== null && _h !== void 0 ? _h : 0;
        return message;
    }
};
function createBaseCCSUsrMsgVotePass() {
    return { team: 0, voteType: 0, dispStr: "", detailsStr: "" };
}
exports.CCSUsrMsgVotePass = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.team !== 0) {
            writer.uint32(8).int32(message.team);
        }
        if (message.voteType !== 0) {
            writer.uint32(16).int32(message.voteType);
        }
        if (message.dispStr !== "") {
            writer.uint32(26).string(message.dispStr);
        }
        if (message.detailsStr !== "") {
            writer.uint32(34).string(message.detailsStr);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgVotePass();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.team = reader.int32();
                    break;
                case 2:
                    message.voteType = reader.int32();
                    break;
                case 3:
                    message.dispStr = reader.string();
                    break;
                case 4:
                    message.detailsStr = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCSUsrMsgVotePass();
        message.team = (_a = object.team) !== null && _a !== void 0 ? _a : 0;
        message.voteType = (_b = object.voteType) !== null && _b !== void 0 ? _b : 0;
        message.dispStr = (_c = object.dispStr) !== null && _c !== void 0 ? _c : "";
        message.detailsStr = (_d = object.detailsStr) !== null && _d !== void 0 ? _d : "";
        return message;
    }
};
function createBaseCCSUsrMsgVoteFailed() {
    return { team: 0, reason: 0 };
}
exports.CCSUsrMsgVoteFailed = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.team !== 0) {
            writer.uint32(8).int32(message.team);
        }
        if (message.reason !== 0) {
            writer.uint32(16).int32(message.reason);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgVoteFailed();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.team = reader.int32();
                    break;
                case 2:
                    message.reason = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCCSUsrMsgVoteFailed();
        message.team = (_a = object.team) !== null && _a !== void 0 ? _a : 0;
        message.reason = (_b = object.reason) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCCSUsrMsgVoteSetup() {
    return { potentialIssues: [] };
}
exports.CCSUsrMsgVoteSetup = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.potentialIssues) {
            writer.uint32(10).string(v);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgVoteSetup();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.potentialIssues.push(reader.string());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgVoteSetup();
        message.potentialIssues = ((_a = object.potentialIssues) === null || _a === void 0 ? void 0 : _a.map(e => e)) || [];
        return message;
    }
};
function createBaseCCSUsrMsgSendLastKillerDamageToClient() {
    return { numHitsGiven: 0, damageGiven: 0, numHitsTaken: 0, damageTaken: 0 };
}
exports.CCSUsrMsgSendLastKillerDamageToClient = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.numHitsGiven !== 0) {
            writer.uint32(8).int32(message.numHitsGiven);
        }
        if (message.damageGiven !== 0) {
            writer.uint32(16).int32(message.damageGiven);
        }
        if (message.numHitsTaken !== 0) {
            writer.uint32(24).int32(message.numHitsTaken);
        }
        if (message.damageTaken !== 0) {
            writer.uint32(32).int32(message.damageTaken);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgSendLastKillerDamageToClient();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.numHitsGiven = reader.int32();
                    break;
                case 2:
                    message.damageGiven = reader.int32();
                    break;
                case 3:
                    message.numHitsTaken = reader.int32();
                    break;
                case 4:
                    message.damageTaken = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCSUsrMsgSendLastKillerDamageToClient();
        message.numHitsGiven = (_a = object.numHitsGiven) !== null && _a !== void 0 ? _a : 0;
        message.damageGiven = (_b = object.damageGiven) !== null && _b !== void 0 ? _b : 0;
        message.numHitsTaken = (_c = object.numHitsTaken) !== null && _c !== void 0 ? _c : 0;
        message.damageTaken = (_d = object.damageTaken) !== null && _d !== void 0 ? _d : 0;
        return message;
    }
};
function createBaseCCSUsrMsgServerRankUpdate() {
    return { rankUpdate: [] };
}
exports.CCSUsrMsgServerRankUpdate = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.rankUpdate) {
            exports.CCSUsrMsgServerRankUpdate_RankUpdate.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgServerRankUpdate();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.rankUpdate.push(exports.CCSUsrMsgServerRankUpdate_RankUpdate.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgServerRankUpdate();
        message.rankUpdate =
            ((_a = object.rankUpdate) === null || _a === void 0 ? void 0 : _a.map(e => exports.CCSUsrMsgServerRankUpdate_RankUpdate.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCCSUsrMsgServerRankUpdate_RankUpdate() {
    return {
        accountId: 0,
        rankOld: 0,
        rankNew: 0,
        numWins: 0,
        rankChange: 0,
        rankTypeId: 0
    };
}
exports.CCSUsrMsgServerRankUpdate_RankUpdate = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountId !== 0) {
            writer.uint32(8).int32(message.accountId);
        }
        if (message.rankOld !== 0) {
            writer.uint32(16).int32(message.rankOld);
        }
        if (message.rankNew !== 0) {
            writer.uint32(24).int32(message.rankNew);
        }
        if (message.numWins !== 0) {
            writer.uint32(32).int32(message.numWins);
        }
        if (message.rankChange !== 0) {
            writer.uint32(45).float(message.rankChange);
        }
        if (message.rankTypeId !== 0) {
            writer.uint32(48).int32(message.rankTypeId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgServerRankUpdate_RankUpdate();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountId = reader.int32();
                    break;
                case 2:
                    message.rankOld = reader.int32();
                    break;
                case 3:
                    message.rankNew = reader.int32();
                    break;
                case 4:
                    message.numWins = reader.int32();
                    break;
                case 5:
                    message.rankChange = reader.float();
                    break;
                case 6:
                    message.rankTypeId = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f;
        const message = createBaseCCSUsrMsgServerRankUpdate_RankUpdate();
        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;
        message.rankOld = (_b = object.rankOld) !== null && _b !== void 0 ? _b : 0;
        message.rankNew = (_c = object.rankNew) !== null && _c !== void 0 ? _c : 0;
        message.numWins = (_d = object.numWins) !== null && _d !== void 0 ? _d : 0;
        message.rankChange = (_e = object.rankChange) !== null && _e !== void 0 ? _e : 0;
        message.rankTypeId = (_f = object.rankTypeId) !== null && _f !== void 0 ? _f : 0;
        return message;
    }
};
function createBaseCCSUsrMsgXpUpdate() {
    return { data: undefined };
}
exports.CCSUsrMsgXpUpdate = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.data !== undefined) {
            cstrike15_gcmessages_1.CMsgGCCstrike15V2GC2ServerNotifyXPRewarded.encode(message.data, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgXpUpdate();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.data = cstrike15_gcmessages_1.CMsgGCCstrike15V2GC2ServerNotifyXPRewarded.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCCSUsrMsgXpUpdate();
        message.data =
            object.data !== undefined && object.data !== null
                ? cstrike15_gcmessages_1.CMsgGCCstrike15V2GC2ServerNotifyXPRewarded.fromPartial(object.data)
                : undefined;
        return message;
    }
};
function createBaseCCSUsrMsgItemPickup() {
    return { item: "" };
}
exports.CCSUsrMsgItemPickup = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.item !== "") {
            writer.uint32(10).string(message.item);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgItemPickup();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.item = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgItemPickup();
        message.item = (_a = object.item) !== null && _a !== void 0 ? _a : "";
        return message;
    }
};
function createBaseCCSUsrMsgShowMenu() {
    return { bitsValidSlots: 0, displayTime: 0, menuString: "" };
}
exports.CCSUsrMsgShowMenu = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.bitsValidSlots !== 0) {
            writer.uint32(8).int32(message.bitsValidSlots);
        }
        if (message.displayTime !== 0) {
            writer.uint32(16).int32(message.displayTime);
        }
        if (message.menuString !== "") {
            writer.uint32(26).string(message.menuString);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgShowMenu();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.bitsValidSlots = reader.int32();
                    break;
                case 2:
                    message.displayTime = reader.int32();
                    break;
                case 3:
                    message.menuString = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCCSUsrMsgShowMenu();
        message.bitsValidSlots = (_a = object.bitsValidSlots) !== null && _a !== void 0 ? _a : 0;
        message.displayTime = (_b = object.displayTime) !== null && _b !== void 0 ? _b : 0;
        message.menuString = (_c = object.menuString) !== null && _c !== void 0 ? _c : "";
        return message;
    }
};
function createBaseCCSUsrMsgBarTime() {
    return { time: "" };
}
exports.CCSUsrMsgBarTime = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.time !== "") {
            writer.uint32(10).string(message.time);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgBarTime();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.time = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgBarTime();
        message.time = (_a = object.time) !== null && _a !== void 0 ? _a : "";
        return message;
    }
};
function createBaseCCSUsrMsgAmmoDenied() {
    return { ammoIdx: 0 };
}
exports.CCSUsrMsgAmmoDenied = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.ammoIdx !== 0) {
            writer.uint32(8).int32(message.ammoIdx);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgAmmoDenied();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.ammoIdx = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgAmmoDenied();
        message.ammoIdx = (_a = object.ammoIdx) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCCSUsrMsgMarkAchievement() {
    return { achievement: "" };
}
exports.CCSUsrMsgMarkAchievement = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.achievement !== "") {
            writer.uint32(10).string(message.achievement);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgMarkAchievement();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.achievement = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgMarkAchievement();
        message.achievement = (_a = object.achievement) !== null && _a !== void 0 ? _a : "";
        return message;
    }
};
function createBaseCCSUsrMsgMatchStatsUpdate() {
    return { update: "" };
}
exports.CCSUsrMsgMatchStatsUpdate = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.update !== "") {
            writer.uint32(10).string(message.update);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgMatchStatsUpdate();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.update = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgMatchStatsUpdate();
        message.update = (_a = object.update) !== null && _a !== void 0 ? _a : "";
        return message;
    }
};
function createBaseCCSUsrMsgItemDrop() {
    return { itemid: Long.ZERO, death: false };
}
exports.CCSUsrMsgItemDrop = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.itemid.isZero()) {
            writer.uint32(8).int64(message.itemid);
        }
        if (message.death === true) {
            writer.uint32(16).bool(message.death);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgItemDrop();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.itemid = reader.int64();
                    break;
                case 2:
                    message.death = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgItemDrop();
        message.itemid =
            object.itemid !== undefined && object.itemid !== null
                ? Long.fromValue(object.itemid)
                : Long.ZERO;
        message.death = (_a = object.death) !== null && _a !== void 0 ? _a : false;
        return message;
    }
};
function createBaseCCSUsrMsgGlowPropTurnOff() {
    return { entidx: 0 };
}
exports.CCSUsrMsgGlowPropTurnOff = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.entidx !== 0) {
            writer.uint32(8).int32(message.entidx);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgGlowPropTurnOff();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.entidx = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgGlowPropTurnOff();
        message.entidx = (_a = object.entidx) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCCSUsrMsgRoundBackupFilenames() {
    return { count: 0, index: 0, filename: "", nicename: "" };
}
exports.CCSUsrMsgRoundBackupFilenames = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.count !== 0) {
            writer.uint32(8).int32(message.count);
        }
        if (message.index !== 0) {
            writer.uint32(16).int32(message.index);
        }
        if (message.filename !== "") {
            writer.uint32(26).string(message.filename);
        }
        if (message.nicename !== "") {
            writer.uint32(34).string(message.nicename);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgRoundBackupFilenames();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.count = reader.int32();
                    break;
                case 2:
                    message.index = reader.int32();
                    break;
                case 3:
                    message.filename = reader.string();
                    break;
                case 4:
                    message.nicename = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCSUsrMsgRoundBackupFilenames();
        message.count = (_a = object.count) !== null && _a !== void 0 ? _a : 0;
        message.index = (_b = object.index) !== null && _b !== void 0 ? _b : 0;
        message.filename = (_c = object.filename) !== null && _c !== void 0 ? _c : "";
        message.nicename = (_d = object.nicename) !== null && _d !== void 0 ? _d : "";
        return message;
    }
};
function createBaseCCSUsrMsgSSUI() {
    return { show: false, startTime: 0, endTime: 0 };
}
exports.CCSUsrMsgSSUI = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.show === true) {
            writer.uint32(8).bool(message.show);
        }
        if (message.startTime !== 0) {
            writer.uint32(21).float(message.startTime);
        }
        if (message.endTime !== 0) {
            writer.uint32(29).float(message.endTime);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgSSUI();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.show = reader.bool();
                    break;
                case 2:
                    message.startTime = reader.float();
                    break;
                case 3:
                    message.endTime = reader.float();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCCSUsrMsgSSUI();
        message.show = (_a = object.show) !== null && _a !== void 0 ? _a : false;
        message.startTime = (_b = object.startTime) !== null && _b !== void 0 ? _b : 0;
        message.endTime = (_c = object.endTime) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseCCSUsrMsgSurvivalStats() {
    return { xuid: Long.UZERO, facts: [], users: [], damages: [], ticknumber: 0 };
}
exports.CCSUsrMsgSurvivalStats = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.xuid.isZero()) {
            writer.uint32(8).uint64(message.xuid);
        }
        for (const v of message.facts) {
            exports.CCSUsrMsgSurvivalStats_Fact.encode(v, writer.uint32(18).fork()).ldelim();
        }
        for (const v of message.users) {
            exports.CCSUsrMsgSurvivalStats_Placement.encode(v, writer.uint32(26).fork()).ldelim();
        }
        for (const v of message.damages) {
            exports.CCSUsrMsgSurvivalStats_Damage.encode(v, writer.uint32(42).fork()).ldelim();
        }
        if (message.ticknumber !== 0) {
            writer.uint32(32).int32(message.ticknumber);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgSurvivalStats();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.xuid = reader.uint64();
                    break;
                case 2:
                    message.facts.push(exports.CCSUsrMsgSurvivalStats_Fact.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.users.push(exports.CCSUsrMsgSurvivalStats_Placement.decode(reader, reader.uint32()));
                    break;
                case 5:
                    message.damages.push(exports.CCSUsrMsgSurvivalStats_Damage.decode(reader, reader.uint32()));
                    break;
                case 4:
                    message.ticknumber = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCSUsrMsgSurvivalStats();
        message.xuid =
            object.xuid !== undefined && object.xuid !== null
                ? Long.fromValue(object.xuid)
                : Long.UZERO;
        message.facts =
            ((_a = object.facts) === null || _a === void 0 ? void 0 : _a.map(e => exports.CCSUsrMsgSurvivalStats_Fact.fromPartial(e))) || [];
        message.users =
            ((_b = object.users) === null || _b === void 0 ? void 0 : _b.map(e => exports.CCSUsrMsgSurvivalStats_Placement.fromPartial(e))) ||
                [];
        message.damages =
            ((_c = object.damages) === null || _c === void 0 ? void 0 : _c.map(e => exports.CCSUsrMsgSurvivalStats_Damage.fromPartial(e))) ||
                [];
        message.ticknumber = (_d = object.ticknumber) !== null && _d !== void 0 ? _d : 0;
        return message;
    }
};
function createBaseCCSUsrMsgSurvivalStats_Fact() {
    return { type: 0, display: 0, value: 0, interestingness: 0 };
}
exports.CCSUsrMsgSurvivalStats_Fact = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.type !== 0) {
            writer.uint32(8).int32(message.type);
        }
        if (message.display !== 0) {
            writer.uint32(16).int32(message.display);
        }
        if (message.value !== 0) {
            writer.uint32(24).int32(message.value);
        }
        if (message.interestingness !== 0) {
            writer.uint32(37).float(message.interestingness);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgSurvivalStats_Fact();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.type = reader.int32();
                    break;
                case 2:
                    message.display = reader.int32();
                    break;
                case 3:
                    message.value = reader.int32();
                    break;
                case 4:
                    message.interestingness = reader.float();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCSUsrMsgSurvivalStats_Fact();
        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;
        message.display = (_b = object.display) !== null && _b !== void 0 ? _b : 0;
        message.value = (_c = object.value) !== null && _c !== void 0 ? _c : 0;
        message.interestingness = (_d = object.interestingness) !== null && _d !== void 0 ? _d : 0;
        return message;
    }
};
function createBaseCCSUsrMsgSurvivalStats_Placement() {
    return { xuid: Long.UZERO, teamnumber: 0, placement: 0 };
}
exports.CCSUsrMsgSurvivalStats_Placement = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.xuid.isZero()) {
            writer.uint32(8).uint64(message.xuid);
        }
        if (message.teamnumber !== 0) {
            writer.uint32(16).int32(message.teamnumber);
        }
        if (message.placement !== 0) {
            writer.uint32(24).int32(message.placement);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgSurvivalStats_Placement();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.xuid = reader.uint64();
                    break;
                case 2:
                    message.teamnumber = reader.int32();
                    break;
                case 3:
                    message.placement = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCCSUsrMsgSurvivalStats_Placement();
        message.xuid =
            object.xuid !== undefined && object.xuid !== null
                ? Long.fromValue(object.xuid)
                : Long.UZERO;
        message.teamnumber = (_a = object.teamnumber) !== null && _a !== void 0 ? _a : 0;
        message.placement = (_b = object.placement) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCCSUsrMsgSurvivalStats_Damage() {
    return { xuid: Long.UZERO, to: 0, toHits: 0, from: 0, fromHits: 0 };
}
exports.CCSUsrMsgSurvivalStats_Damage = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.xuid.isZero()) {
            writer.uint32(8).uint64(message.xuid);
        }
        if (message.to !== 0) {
            writer.uint32(16).int32(message.to);
        }
        if (message.toHits !== 0) {
            writer.uint32(24).int32(message.toHits);
        }
        if (message.from !== 0) {
            writer.uint32(32).int32(message.from);
        }
        if (message.fromHits !== 0) {
            writer.uint32(40).int32(message.fromHits);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgSurvivalStats_Damage();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.xuid = reader.uint64();
                    break;
                case 2:
                    message.to = reader.int32();
                    break;
                case 3:
                    message.toHits = reader.int32();
                    break;
                case 4:
                    message.from = reader.int32();
                    break;
                case 5:
                    message.fromHits = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCSUsrMsgSurvivalStats_Damage();
        message.xuid =
            object.xuid !== undefined && object.xuid !== null
                ? Long.fromValue(object.xuid)
                : Long.UZERO;
        message.to = (_a = object.to) !== null && _a !== void 0 ? _a : 0;
        message.toHits = (_b = object.toHits) !== null && _b !== void 0 ? _b : 0;
        message.from = (_c = object.from) !== null && _c !== void 0 ? _c : 0;
        message.fromHits = (_d = object.fromHits) !== null && _d !== void 0 ? _d : 0;
        return message;
    }
};
function createBaseCCSUsrMsgEndOfMatchAllPlayersData() {
    return { allplayerdata: [], scene: 0 };
}
exports.CCSUsrMsgEndOfMatchAllPlayersData = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.allplayerdata) {
            exports.CCSUsrMsgEndOfMatchAllPlayersData_PlayerData.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.scene !== 0) {
            writer.uint32(16).int32(message.scene);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgEndOfMatchAllPlayersData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.allplayerdata.push(exports.CCSUsrMsgEndOfMatchAllPlayersData_PlayerData.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.scene = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCCSUsrMsgEndOfMatchAllPlayersData();
        message.allplayerdata =
            ((_a = object.allplayerdata) === null || _a === void 0 ? void 0 : _a.map(e => exports.CCSUsrMsgEndOfMatchAllPlayersData_PlayerData.fromPartial(e))) || [];
        message.scene = (_b = object.scene) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCCSUsrMsgEndOfMatchAllPlayersData_Accolade() {
    return { eaccolade: 0, value: 0, position: 0 };
}
exports.CCSUsrMsgEndOfMatchAllPlayersData_Accolade = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.eaccolade !== 0) {
            writer.uint32(8).int32(message.eaccolade);
        }
        if (message.value !== 0) {
            writer.uint32(21).float(message.value);
        }
        if (message.position !== 0) {
            writer.uint32(24).int32(message.position);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgEndOfMatchAllPlayersData_Accolade();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.eaccolade = reader.int32();
                    break;
                case 2:
                    message.value = reader.float();
                    break;
                case 3:
                    message.position = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCCSUsrMsgEndOfMatchAllPlayersData_Accolade();
        message.eaccolade = (_a = object.eaccolade) !== null && _a !== void 0 ? _a : 0;
        message.value = (_b = object.value) !== null && _b !== void 0 ? _b : 0;
        message.position = (_c = object.position) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseCCSUsrMsgEndOfMatchAllPlayersData_PlayerData() {
    return {
        entindex: 0,
        xuid: Long.UZERO,
        name: "",
        teamnumber: 0,
        nomination: undefined,
        items: [],
        playercolor: 0,
        isbot: false
    };
}
exports.CCSUsrMsgEndOfMatchAllPlayersData_PlayerData = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.entindex !== 0) {
            writer.uint32(8).int32(message.entindex);
        }
        if (!message.xuid.isZero()) {
            writer.uint32(16).uint64(message.xuid);
        }
        if (message.name !== "") {
            writer.uint32(26).string(message.name);
        }
        if (message.teamnumber !== 0) {
            writer.uint32(32).int32(message.teamnumber);
        }
        if (message.nomination !== undefined) {
            exports.CCSUsrMsgEndOfMatchAllPlayersData_Accolade.encode(message.nomination, writer.uint32(42).fork()).ldelim();
        }
        for (const v of message.items) {
            cstrike15_gcmessages_1.CEconItemPreviewDataBlock.encode(v, writer.uint32(50).fork()).ldelim();
        }
        if (message.playercolor !== 0) {
            writer.uint32(56).int32(message.playercolor);
        }
        if (message.isbot === true) {
            writer.uint32(64).bool(message.isbot);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgEndOfMatchAllPlayersData_PlayerData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.entindex = reader.int32();
                    break;
                case 2:
                    message.xuid = reader.uint64();
                    break;
                case 3:
                    message.name = reader.string();
                    break;
                case 4:
                    message.teamnumber = reader.int32();
                    break;
                case 5:
                    message.nomination =
                        exports.CCSUsrMsgEndOfMatchAllPlayersData_Accolade.decode(reader, reader.uint32());
                    break;
                case 6:
                    message.items.push(cstrike15_gcmessages_1.CEconItemPreviewDataBlock.decode(reader, reader.uint32()));
                    break;
                case 7:
                    message.playercolor = reader.int32();
                    break;
                case 8:
                    message.isbot = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f;
        const message = createBaseCCSUsrMsgEndOfMatchAllPlayersData_PlayerData();
        message.entindex = (_a = object.entindex) !== null && _a !== void 0 ? _a : 0;
        message.xuid =
            object.xuid !== undefined && object.xuid !== null
                ? Long.fromValue(object.xuid)
                : Long.UZERO;
        message.name = (_b = object.name) !== null && _b !== void 0 ? _b : "";
        message.teamnumber = (_c = object.teamnumber) !== null && _c !== void 0 ? _c : 0;
        message.nomination =
            object.nomination !== undefined && object.nomination !== null
                ? exports.CCSUsrMsgEndOfMatchAllPlayersData_Accolade.fromPartial(object.nomination)
                : undefined;
        message.items =
            ((_d = object.items) === null || _d === void 0 ? void 0 : _d.map(e => cstrike15_gcmessages_1.CEconItemPreviewDataBlock.fromPartial(e))) || [];
        message.playercolor = (_e = object.playercolor) !== null && _e !== void 0 ? _e : 0;
        message.isbot = (_f = object.isbot) !== null && _f !== void 0 ? _f : false;
        return message;
    }
};
function createBaseCCSUsrMsgRoundImpactScoreData() {
    return { initConditions: undefined, allRisEventData: [] };
}
exports.CCSUsrMsgRoundImpactScoreData = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.initConditions !== undefined) {
            exports.CCSUsrMsgRoundImpactScoreData_InitialConditions.encode(message.initConditions, writer.uint32(10).fork()).ldelim();
        }
        for (const v of message.allRisEventData) {
            exports.CCSUsrMsgRoundImpactScoreData_RisEvent.encode(v, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgRoundImpactScoreData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.initConditions =
                        exports.CCSUsrMsgRoundImpactScoreData_InitialConditions.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.allRisEventData.push(exports.CCSUsrMsgRoundImpactScoreData_RisEvent.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgRoundImpactScoreData();
        message.initConditions =
            object.initConditions !== undefined && object.initConditions !== null
                ? exports.CCSUsrMsgRoundImpactScoreData_InitialConditions.fromPartial(object.initConditions)
                : undefined;
        message.allRisEventData =
            ((_a = object.allRisEventData) === null || _a === void 0 ? void 0 : _a.map(e => exports.CCSUsrMsgRoundImpactScoreData_RisEvent.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCCSUsrMsgRoundImpactScoreData_RisEvent() {
    return {
        timestamp: 0,
        terroristOdds: 0,
        ctAlive: 0,
        tAlive: 0,
        victimData: undefined,
        objectiveData: undefined,
        allDamageData: []
    };
}
exports.CCSUsrMsgRoundImpactScoreData_RisEvent = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.timestamp !== 0) {
            writer.uint32(13).float(message.timestamp);
        }
        if (message.terroristOdds !== 0) {
            writer.uint32(16).int32(message.terroristOdds);
        }
        if (message.ctAlive !== 0) {
            writer.uint32(24).int32(message.ctAlive);
        }
        if (message.tAlive !== 0) {
            writer.uint32(32).int32(message.tAlive);
        }
        if (message.victimData !== undefined) {
            exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Victim.encode(message.victimData, writer.uint32(42).fork()).ldelim();
        }
        if (message.objectiveData !== undefined) {
            exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Objective.encode(message.objectiveData, writer.uint32(50).fork()).ldelim();
        }
        for (const v of message.allDamageData) {
            exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Damage.encode(v, writer.uint32(58).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgRoundImpactScoreData_RisEvent();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.timestamp = reader.float();
                    break;
                case 2:
                    message.terroristOdds = reader.int32();
                    break;
                case 3:
                    message.ctAlive = reader.int32();
                    break;
                case 4:
                    message.tAlive = reader.int32();
                    break;
                case 5:
                    message.victimData =
                        exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Victim.decode(reader, reader.uint32());
                    break;
                case 6:
                    message.objectiveData =
                        exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Objective.decode(reader, reader.uint32());
                    break;
                case 7:
                    message.allDamageData.push(exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Damage.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseCCSUsrMsgRoundImpactScoreData_RisEvent();
        message.timestamp = (_a = object.timestamp) !== null && _a !== void 0 ? _a : 0;
        message.terroristOdds = (_b = object.terroristOdds) !== null && _b !== void 0 ? _b : 0;
        message.ctAlive = (_c = object.ctAlive) !== null && _c !== void 0 ? _c : 0;
        message.tAlive = (_d = object.tAlive) !== null && _d !== void 0 ? _d : 0;
        message.victimData =
            object.victimData !== undefined && object.victimData !== null
                ? exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Victim.fromPartial(object.victimData)
                : undefined;
        message.objectiveData =
            object.objectiveData !== undefined && object.objectiveData !== null
                ? exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Objective.fromPartial(object.objectiveData)
                : undefined;
        message.allDamageData =
            ((_e = object.allDamageData) === null || _e === void 0 ? void 0 : _e.map(e => exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Damage.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Victim() {
    return {
        teamNumber: 0,
        entindex: 0,
        xuid: Long.UZERO,
        color: 0,
        isBot: false,
        isDead: false
    };
}
exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Victim = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.teamNumber !== 0) {
            writer.uint32(8).int32(message.teamNumber);
        }
        if (message.entindex !== 0) {
            writer.uint32(16).int32(message.entindex);
        }
        if (!message.xuid.isZero()) {
            writer.uint32(24).uint64(message.xuid);
        }
        if (message.color !== 0) {
            writer.uint32(32).int32(message.color);
        }
        if (message.isBot === true) {
            writer.uint32(40).bool(message.isBot);
        }
        if (message.isDead === true) {
            writer.uint32(48).bool(message.isDead);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Victim();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.teamNumber = reader.int32();
                    break;
                case 2:
                    message.entindex = reader.int32();
                    break;
                case 3:
                    message.xuid = reader.uint64();
                    break;
                case 4:
                    message.color = reader.int32();
                    break;
                case 5:
                    message.isBot = reader.bool();
                    break;
                case 6:
                    message.isDead = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Victim();
        message.teamNumber = (_a = object.teamNumber) !== null && _a !== void 0 ? _a : 0;
        message.entindex = (_b = object.entindex) !== null && _b !== void 0 ? _b : 0;
        message.xuid =
            object.xuid !== undefined && object.xuid !== null
                ? Long.fromValue(object.xuid)
                : Long.UZERO;
        message.color = (_c = object.color) !== null && _c !== void 0 ? _c : 0;
        message.isBot = (_d = object.isBot) !== null && _d !== void 0 ? _d : false;
        message.isDead = (_e = object.isDead) !== null && _e !== void 0 ? _e : false;
        return message;
    }
};
function createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Objective() {
    return { type: 0 };
}
exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Objective = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.type !== 0) {
            writer.uint32(8).int32(message.type);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Objective();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.type = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Objective();
        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Damage() {
    return {
        targetEntindex: 0,
        targetXuid: Long.UZERO,
        healthRemoved: 0,
        numHits: 0,
        returnHealthRemoved: 0,
        numReturnHits: 0
    };
}
exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Damage = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.targetEntindex !== 0) {
            writer.uint32(8).int32(message.targetEntindex);
        }
        if (!message.targetXuid.isZero()) {
            writer.uint32(16).uint64(message.targetXuid);
        }
        if (message.healthRemoved !== 0) {
            writer.uint32(24).int32(message.healthRemoved);
        }
        if (message.numHits !== 0) {
            writer.uint32(32).int32(message.numHits);
        }
        if (message.returnHealthRemoved !== 0) {
            writer.uint32(40).int32(message.returnHealthRemoved);
        }
        if (message.numReturnHits !== 0) {
            writer.uint32(48).int32(message.numReturnHits);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Damage();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.targetEntindex = reader.int32();
                    break;
                case 2:
                    message.targetXuid = reader.uint64();
                    break;
                case 3:
                    message.healthRemoved = reader.int32();
                    break;
                case 4:
                    message.numHits = reader.int32();
                    break;
                case 5:
                    message.returnHealthRemoved = reader.int32();
                    break;
                case 6:
                    message.numReturnHits = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Damage();
        message.targetEntindex = (_a = object.targetEntindex) !== null && _a !== void 0 ? _a : 0;
        message.targetXuid =
            object.targetXuid !== undefined && object.targetXuid !== null
                ? Long.fromValue(object.targetXuid)
                : Long.UZERO;
        message.healthRemoved = (_b = object.healthRemoved) !== null && _b !== void 0 ? _b : 0;
        message.numHits = (_c = object.numHits) !== null && _c !== void 0 ? _c : 0;
        message.returnHealthRemoved = (_d = object.returnHealthRemoved) !== null && _d !== void 0 ? _d : 0;
        message.numReturnHits = (_e = object.numReturnHits) !== null && _e !== void 0 ? _e : 0;
        return message;
    }
};
function createBaseCCSUsrMsgRoundImpactScoreData_InitialConditions() {
    return { ctEquipValue: 0, tEquipValue: 0, terroristOdds: 0 };
}
exports.CCSUsrMsgRoundImpactScoreData_InitialConditions = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.ctEquipValue !== 0) {
            writer.uint32(8).int32(message.ctEquipValue);
        }
        if (message.tEquipValue !== 0) {
            writer.uint32(16).int32(message.tEquipValue);
        }
        if (message.terroristOdds !== 0) {
            writer.uint32(24).int32(message.terroristOdds);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgRoundImpactScoreData_InitialConditions();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.ctEquipValue = reader.int32();
                    break;
                case 2:
                    message.tEquipValue = reader.int32();
                    break;
                case 3:
                    message.terroristOdds = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCCSUsrMsgRoundImpactScoreData_InitialConditions();
        message.ctEquipValue = (_a = object.ctEquipValue) !== null && _a !== void 0 ? _a : 0;
        message.tEquipValue = (_b = object.tEquipValue) !== null && _b !== void 0 ? _b : 0;
        message.terroristOdds = (_c = object.terroristOdds) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseCCSUsrMsgCurrentRoundOdds() {
    return { odds: 0 };
}
exports.CCSUsrMsgCurrentRoundOdds = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.odds !== 0) {
            writer.uint32(8).int32(message.odds);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgCurrentRoundOdds();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.odds = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgCurrentRoundOdds();
        message.odds = (_a = object.odds) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCCSUsrMsgDeepStats() {
    return { stats: undefined };
}
exports.CCSUsrMsgDeepStats = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.stats !== undefined) {
            cstrike15_gcmessages_1.CMsgGCCStrike15ClientDeepStats.encode(message.stats, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgDeepStats();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.stats = cstrike15_gcmessages_1.CMsgGCCStrike15ClientDeepStats.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCCSUsrMsgDeepStats();
        message.stats =
            object.stats !== undefined && object.stats !== null
                ? cstrike15_gcmessages_1.CMsgGCCStrike15ClientDeepStats.fromPartial(object.stats)
                : undefined;
        return message;
    }
};
function createBaseCCSUsrMsgResetHud() {
    return { reset: false };
}
exports.CCSUsrMsgResetHud = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.reset === true) {
            writer.uint32(8).bool(message.reset);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgResetHud();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.reset = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgResetHud();
        message.reset = (_a = object.reset) !== null && _a !== void 0 ? _a : false;
        return message;
    }
};
function createBaseCCSUsrMsgGameTitle() {
    return { dummy: 0 };
}
exports.CCSUsrMsgGameTitle = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.dummy !== 0) {
            writer.uint32(8).int32(message.dummy);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgGameTitle();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.dummy = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgGameTitle();
        message.dummy = (_a = object.dummy) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCCSUsrMsgRequestState() {
    return { dummy: 0 };
}
exports.CCSUsrMsgRequestState = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.dummy !== 0) {
            writer.uint32(8).int32(message.dummy);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgRequestState();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.dummy = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgRequestState();
        message.dummy = (_a = object.dummy) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCCSUsrMsgStopSpectatorMode() {
    return { dummy: 0 };
}
exports.CCSUsrMsgStopSpectatorMode = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.dummy !== 0) {
            writer.uint32(8).int32(message.dummy);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgStopSpectatorMode();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.dummy = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgStopSpectatorMode();
        message.dummy = (_a = object.dummy) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCCSUsrMsgDisconnectToLobby() {
    return { dummy: 0 };
}
exports.CCSUsrMsgDisconnectToLobby = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.dummy !== 0) {
            writer.uint32(8).int32(message.dummy);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgDisconnectToLobby();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.dummy = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgDisconnectToLobby();
        message.dummy = (_a = object.dummy) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCCSUsrMsgWarmupHasEnded() {
    return { dummy: 0 };
}
exports.CCSUsrMsgWarmupHasEnded = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.dummy !== 0) {
            writer.uint32(8).int32(message.dummy);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgWarmupHasEnded();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.dummy = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgWarmupHasEnded();
        message.dummy = (_a = object.dummy) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCCSUsrMsgClientInfo() {
    return { dummy: 0 };
}
exports.CCSUsrMsgClientInfo = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.dummy !== 0) {
            writer.uint32(8).int32(message.dummy);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgClientInfo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.dummy = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgClientInfo();
        message.dummy = (_a = object.dummy) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCCSUsrMsgServerRankRevealAll() {
    return { secondsTillShutdown: 0, reservation: undefined };
}
exports.CCSUsrMsgServerRankRevealAll = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.secondsTillShutdown !== 0) {
            writer.uint32(8).int32(message.secondsTillShutdown);
        }
        if (message.reservation !== undefined) {
            cstrike15_gcmessages_1.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.encode(message.reservation, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgServerRankRevealAll();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.secondsTillShutdown = reader.int32();
                    break;
                case 2:
                    message.reservation =
                        cstrike15_gcmessages_1.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCSUsrMsgServerRankRevealAll();
        message.secondsTillShutdown = (_a = object.secondsTillShutdown) !== null && _a !== void 0 ? _a : 0;
        message.reservation =
            object.reservation !== undefined && object.reservation !== null
                ? cstrike15_gcmessages_1.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.fromPartial(object.reservation)
                : undefined;
        return message;
    }
};
function createBaseCCSUsrMsgUtilMsg() {
    return { utilAction: "", util1: 0, util2: 0, util3: 0, util4: 0, util5: 0 };
}
exports.CCSUsrMsgUtilMsg = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.utilAction !== "") {
            writer.uint32(10).string(message.utilAction);
        }
        if (message.util1 !== 0) {
            writer.uint32(16).int32(message.util1);
        }
        if (message.util2 !== 0) {
            writer.uint32(24).int32(message.util2);
        }
        if (message.util3 !== 0) {
            writer.uint32(32).int32(message.util3);
        }
        if (message.util4 !== 0) {
            writer.uint32(40).int32(message.util4);
        }
        if (message.util5 !== 0) {
            writer.uint32(48).int32(message.util5);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCSUsrMsgUtilMsg();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.utilAction = reader.string();
                    break;
                case 2:
                    message.util1 = reader.int32();
                    break;
                case 3:
                    message.util2 = reader.int32();
                    break;
                case 4:
                    message.util3 = reader.int32();
                    break;
                case 5:
                    message.util4 = reader.int32();
                    break;
                case 6:
                    message.util5 = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f;
        const message = createBaseCCSUsrMsgUtilMsg();
        message.utilAction = (_a = object.utilAction) !== null && _a !== void 0 ? _a : "";
        message.util1 = (_b = object.util1) !== null && _b !== void 0 ? _b : 0;
        message.util2 = (_c = object.util2) !== null && _c !== void 0 ? _c : 0;
        message.util3 = (_d = object.util3) !== null && _d !== void 0 ? _d : 0;
        message.util4 = (_e = object.util4) !== null && _e !== void 0 ? _e : 0;
        message.util5 = (_f = object.util5) !== null && _f !== void 0 ? _f : 0;
        return message;
    }
};
// If you get a compile-error about 'Constructor<Long> and ... have no overlap',
// add '--ts_proto_opt=esModuleInterop=true' as a flag when calling 'protoc'.
if (minimal_1.util.Long !== Long) {
    minimal_1.util.Long = Long;
    (0, minimal_1.configure)();
}

},{"./cstrike15_gcmessages":24,"./netmessages":27,"long":712,"protobufjs/minimal":715}],26:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CEngineGotvSyncPacket = exports.protobufPackage = void 0;
/* eslint-disable */
const minimal_1 = require("protobufjs/minimal");
const Long = require("long");
exports.protobufPackage = "";
function createBaseCEngineGotvSyncPacket() {
    return {
        matchId: Long.UZERO,
        instanceId: 0,
        signupfragment: 0,
        currentfragment: 0,
        tickrate: 0,
        tick: 0,
        rtdelay: 0,
        rcvage: 0,
        keyframeInterval: 0,
        cdndelay: 0
    };
}
exports.CEngineGotvSyncPacket = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (!message.matchId.isZero()) {
            writer.uint32(8).uint64(message.matchId);
        }
        if (message.instanceId !== 0) {
            writer.uint32(16).uint32(message.instanceId);
        }
        if (message.signupfragment !== 0) {
            writer.uint32(24).uint32(message.signupfragment);
        }
        if (message.currentfragment !== 0) {
            writer.uint32(32).uint32(message.currentfragment);
        }
        if (message.tickrate !== 0) {
            writer.uint32(45).float(message.tickrate);
        }
        if (message.tick !== 0) {
            writer.uint32(48).uint32(message.tick);
        }
        if (message.rtdelay !== 0) {
            writer.uint32(69).float(message.rtdelay);
        }
        if (message.rcvage !== 0) {
            writer.uint32(77).float(message.rcvage);
        }
        if (message.keyframeInterval !== 0) {
            writer.uint32(85).float(message.keyframeInterval);
        }
        if (message.cdndelay !== 0) {
            writer.uint32(88).uint32(message.cdndelay);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCEngineGotvSyncPacket();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.matchId = reader.uint64();
                    break;
                case 2:
                    message.instanceId = reader.uint32();
                    break;
                case 3:
                    message.signupfragment = reader.uint32();
                    break;
                case 4:
                    message.currentfragment = reader.uint32();
                    break;
                case 5:
                    message.tickrate = reader.float();
                    break;
                case 6:
                    message.tick = reader.uint32();
                    break;
                case 8:
                    message.rtdelay = reader.float();
                    break;
                case 9:
                    message.rcvage = reader.float();
                    break;
                case 10:
                    message.keyframeInterval = reader.float();
                    break;
                case 11:
                    message.cdndelay = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
        const message = createBaseCEngineGotvSyncPacket();
        message.matchId =
            object.matchId !== undefined && object.matchId !== null
                ? Long.fromValue(object.matchId)
                : Long.UZERO;
        message.instanceId = (_a = object.instanceId) !== null && _a !== void 0 ? _a : 0;
        message.signupfragment = (_b = object.signupfragment) !== null && _b !== void 0 ? _b : 0;
        message.currentfragment = (_c = object.currentfragment) !== null && _c !== void 0 ? _c : 0;
        message.tickrate = (_d = object.tickrate) !== null && _d !== void 0 ? _d : 0;
        message.tick = (_e = object.tick) !== null && _e !== void 0 ? _e : 0;
        message.rtdelay = (_f = object.rtdelay) !== null && _f !== void 0 ? _f : 0;
        message.rcvage = (_g = object.rcvage) !== null && _g !== void 0 ? _g : 0;
        message.keyframeInterval = (_h = object.keyframeInterval) !== null && _h !== void 0 ? _h : 0;
        message.cdndelay = (_j = object.cdndelay) !== null && _j !== void 0 ? _j : 0;
        return message;
    }
};
// If you get a compile-error about 'Constructor<Long> and ... have no overlap',
// add '--ts_proto_opt=esModuleInterop=true' as a flag when calling 'protoc'.
if (minimal_1.util.Long !== Long) {
    minimal_1.util.Long = Long;
    (0, minimal_1.configure)();
}

},{"long":712,"protobufjs/minimal":715}],27:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CSVCMsgGetCvarValue = exports.CSVCMsgSplitScreen = exports.CSVCMsgBSPDecal = exports.CSVCMsgPrefetch = exports.CSVCMsgCrosshairAngle = exports.CSVCMsgFixAngle = exports.CSVCMsgVoiceData = exports.CSVCMsgVoiceInit = exports.CSVCMsgUpdateStringTable = exports.CSVCMsgCreateStringTable = exports.CSVCMsgSetView = exports.CSVCMsgSetPause = exports.CSVCMsgPrint = exports.CSVCMsgSendTable_sendpropT = exports.CSVCMsgSendTable = exports.CSVCMsgClassInfo_classT = exports.CSVCMsgClassInfo = exports.CSVCMsgServerInfo = exports.CCLCMsgCmdKeyValues = exports.CCLCMsgSplitPlayerConnect = exports.CCLCMsgLoadingProgress = exports.CCLCMsgFileCRCCheck = exports.CCLCMsgRespondCvarValue = exports.CCLCMsgListenEvents = exports.CCLCMsgBaselineAck = exports.CCLCMsgVoiceData = exports.CCLCMsgMove = exports.CCLCMsgClientInfo = exports.CNETMsgPlayerAvatarData = exports.CNETMsgSplitScreenUser = exports.CNETMsgFile = exports.CNETMsgDisconnect = exports.CNETMsgNOP = exports.CNETMsgSetConVar = exports.CMsgCVars_CVar = exports.CMsgCVars = exports.CNETMsgSignonState = exports.CNETMsgStringCmd = exports.CNETMsgTick = exports.CMsgRGBA = exports.CMsgQAngle = exports.CMsgVector2D = exports.CMsgVector = exports.ReplayEventTypeT = exports.SVCMessages = exports.ESplitScreenMessageType = exports.VoiceDataFormatT = exports.CLCMessages = exports.NETMessages = exports.protobufPackage = void 0;
exports.CSVCMsgBroadcastCommand = exports.CCLCMsgHltvReplay = exports.CSVCMsgHltvReplay = exports.CSVCMsgEncryptedData = exports.CSVCMsgCmdKeyValues = exports.CSVCMsgEntityMsg = exports.CSVCMsgSounds_sounddataT = exports.CSVCMsgSounds = exports.CSVCMsgPacketEntities = exports.CSVCMsgTempEntities = exports.CSVCMsgGameEventList_descriptorT = exports.CSVCMsgGameEventList_keyT = exports.CSVCMsgGameEventList = exports.CSVCMsgGameEvent_keyT = exports.CSVCMsgGameEvent = exports.CSVCMsgPaintmapData = exports.CSVCMsgUserMessage = exports.CSVCMsgMenu = void 0;
/* eslint-disable */
const minimal_1 = require("protobufjs/minimal");
const Long = require("long");
exports.protobufPackage = "";
var NETMessages;
(function (NETMessages) {
    NETMessages[NETMessages["net_NOP"] = 0] = "net_NOP";
    NETMessages[NETMessages["net_Disconnect"] = 1] = "net_Disconnect";
    NETMessages[NETMessages["net_File"] = 2] = "net_File";
    NETMessages[NETMessages["net_SplitScreenUser"] = 3] = "net_SplitScreenUser";
    NETMessages[NETMessages["net_Tick"] = 4] = "net_Tick";
    NETMessages[NETMessages["net_StringCmd"] = 5] = "net_StringCmd";
    NETMessages[NETMessages["net_SetConVar"] = 6] = "net_SetConVar";
    NETMessages[NETMessages["net_SignonState"] = 7] = "net_SignonState";
    NETMessages[NETMessages["net_PlayerAvatarData"] = 100] = "net_PlayerAvatarData";
})(NETMessages = exports.NETMessages || (exports.NETMessages = {}));
var CLCMessages;
(function (CLCMessages) {
    CLCMessages[CLCMessages["clc_ClientInfo"] = 8] = "clc_ClientInfo";
    CLCMessages[CLCMessages["clc_Move"] = 9] = "clc_Move";
    CLCMessages[CLCMessages["clc_VoiceData"] = 10] = "clc_VoiceData";
    CLCMessages[CLCMessages["clc_BaselineAck"] = 11] = "clc_BaselineAck";
    CLCMessages[CLCMessages["clc_ListenEvents"] = 12] = "clc_ListenEvents";
    CLCMessages[CLCMessages["clc_RespondCvarValue"] = 13] = "clc_RespondCvarValue";
    CLCMessages[CLCMessages["clc_FileCRCCheck"] = 14] = "clc_FileCRCCheck";
    CLCMessages[CLCMessages["clc_LoadingProgress"] = 15] = "clc_LoadingProgress";
    CLCMessages[CLCMessages["clc_SplitPlayerConnect"] = 16] = "clc_SplitPlayerConnect";
    CLCMessages[CLCMessages["clc_ClientMessage"] = 17] = "clc_ClientMessage";
    CLCMessages[CLCMessages["clc_CmdKeyValues"] = 18] = "clc_CmdKeyValues";
    CLCMessages[CLCMessages["clc_HltvReplay"] = 20] = "clc_HltvReplay";
})(CLCMessages = exports.CLCMessages || (exports.CLCMessages = {}));
var VoiceDataFormatT;
(function (VoiceDataFormatT) {
    VoiceDataFormatT[VoiceDataFormatT["VOICEDATA_FORMAT_STEAM"] = 0] = "VOICEDATA_FORMAT_STEAM";
    VoiceDataFormatT[VoiceDataFormatT["VOICEDATA_FORMAT_ENGINE"] = 1] = "VOICEDATA_FORMAT_ENGINE";
})(VoiceDataFormatT = exports.VoiceDataFormatT || (exports.VoiceDataFormatT = {}));
var ESplitScreenMessageType;
(function (ESplitScreenMessageType) {
    ESplitScreenMessageType[ESplitScreenMessageType["MSG_SPLITSCREEN_ADDUSER"] = 0] = "MSG_SPLITSCREEN_ADDUSER";
    ESplitScreenMessageType[ESplitScreenMessageType["MSG_SPLITSCREEN_REMOVEUSER"] = 1] = "MSG_SPLITSCREEN_REMOVEUSER";
    ESplitScreenMessageType[ESplitScreenMessageType["MSG_SPLITSCREEN_TYPE_BITS"] = 1] = "MSG_SPLITSCREEN_TYPE_BITS";
})(ESplitScreenMessageType = exports.ESplitScreenMessageType || (exports.ESplitScreenMessageType = {}));
var SVCMessages;
(function (SVCMessages) {
    SVCMessages[SVCMessages["svc_ServerInfo"] = 8] = "svc_ServerInfo";
    SVCMessages[SVCMessages["svc_SendTable"] = 9] = "svc_SendTable";
    SVCMessages[SVCMessages["svc_ClassInfo"] = 10] = "svc_ClassInfo";
    SVCMessages[SVCMessages["svc_SetPause"] = 11] = "svc_SetPause";
    SVCMessages[SVCMessages["svc_CreateStringTable"] = 12] = "svc_CreateStringTable";
    SVCMessages[SVCMessages["svc_UpdateStringTable"] = 13] = "svc_UpdateStringTable";
    SVCMessages[SVCMessages["svc_VoiceInit"] = 14] = "svc_VoiceInit";
    SVCMessages[SVCMessages["svc_VoiceData"] = 15] = "svc_VoiceData";
    SVCMessages[SVCMessages["svc_Print"] = 16] = "svc_Print";
    SVCMessages[SVCMessages["svc_Sounds"] = 17] = "svc_Sounds";
    SVCMessages[SVCMessages["svc_SetView"] = 18] = "svc_SetView";
    SVCMessages[SVCMessages["svc_FixAngle"] = 19] = "svc_FixAngle";
    SVCMessages[SVCMessages["svc_CrosshairAngle"] = 20] = "svc_CrosshairAngle";
    SVCMessages[SVCMessages["svc_BSPDecal"] = 21] = "svc_BSPDecal";
    SVCMessages[SVCMessages["svc_SplitScreen"] = 22] = "svc_SplitScreen";
    SVCMessages[SVCMessages["svc_UserMessage"] = 23] = "svc_UserMessage";
    SVCMessages[SVCMessages["svc_EntityMessage"] = 24] = "svc_EntityMessage";
    SVCMessages[SVCMessages["svc_GameEvent"] = 25] = "svc_GameEvent";
    SVCMessages[SVCMessages["svc_PacketEntities"] = 26] = "svc_PacketEntities";
    SVCMessages[SVCMessages["svc_TempEntities"] = 27] = "svc_TempEntities";
    SVCMessages[SVCMessages["svc_Prefetch"] = 28] = "svc_Prefetch";
    SVCMessages[SVCMessages["svc_Menu"] = 29] = "svc_Menu";
    SVCMessages[SVCMessages["svc_GameEventList"] = 30] = "svc_GameEventList";
    SVCMessages[SVCMessages["svc_GetCvarValue"] = 31] = "svc_GetCvarValue";
    SVCMessages[SVCMessages["svc_PaintmapData"] = 33] = "svc_PaintmapData";
    SVCMessages[SVCMessages["svc_CmdKeyValues"] = 34] = "svc_CmdKeyValues";
    SVCMessages[SVCMessages["svc_EncryptedData"] = 35] = "svc_EncryptedData";
    SVCMessages[SVCMessages["svc_HltvReplay"] = 36] = "svc_HltvReplay";
    SVCMessages[SVCMessages["svc_Broadcast_Command"] = 38] = "svc_Broadcast_Command";
})(SVCMessages = exports.SVCMessages || (exports.SVCMessages = {}));
var ReplayEventTypeT;
(function (ReplayEventTypeT) {
    ReplayEventTypeT[ReplayEventTypeT["REPLAY_EVENT_CANCEL"] = 0] = "REPLAY_EVENT_CANCEL";
    ReplayEventTypeT[ReplayEventTypeT["REPLAY_EVENT_DEATH"] = 1] = "REPLAY_EVENT_DEATH";
    ReplayEventTypeT[ReplayEventTypeT["REPLAY_EVENT_GENERIC"] = 2] = "REPLAY_EVENT_GENERIC";
    ReplayEventTypeT[ReplayEventTypeT["REPLAY_EVENT_STUCK_NEED_FULL_UPDATE"] = 3] = "REPLAY_EVENT_STUCK_NEED_FULL_UPDATE";
})(ReplayEventTypeT = exports.ReplayEventTypeT || (exports.ReplayEventTypeT = {}));
function createBaseCMsgVector() {
    return { x: 0, y: 0, z: 0 };
}
exports.CMsgVector = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.x !== 0) {
            writer.uint32(13).float(message.x);
        }
        if (message.y !== 0) {
            writer.uint32(21).float(message.y);
        }
        if (message.z !== 0) {
            writer.uint32(29).float(message.z);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgVector();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.x = reader.float();
                    break;
                case 2:
                    message.y = reader.float();
                    break;
                case 3:
                    message.z = reader.float();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCMsgVector();
        message.x = (_a = object.x) !== null && _a !== void 0 ? _a : 0;
        message.y = (_b = object.y) !== null && _b !== void 0 ? _b : 0;
        message.z = (_c = object.z) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseCMsgVector2D() {
    return { x: 0, y: 0 };
}
exports.CMsgVector2D = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.x !== 0) {
            writer.uint32(13).float(message.x);
        }
        if (message.y !== 0) {
            writer.uint32(21).float(message.y);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgVector2D();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.x = reader.float();
                    break;
                case 2:
                    message.y = reader.float();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCMsgVector2D();
        message.x = (_a = object.x) !== null && _a !== void 0 ? _a : 0;
        message.y = (_b = object.y) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCMsgQAngle() {
    return { x: 0, y: 0, z: 0 };
}
exports.CMsgQAngle = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.x !== 0) {
            writer.uint32(13).float(message.x);
        }
        if (message.y !== 0) {
            writer.uint32(21).float(message.y);
        }
        if (message.z !== 0) {
            writer.uint32(29).float(message.z);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgQAngle();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.x = reader.float();
                    break;
                case 2:
                    message.y = reader.float();
                    break;
                case 3:
                    message.z = reader.float();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCMsgQAngle();
        message.x = (_a = object.x) !== null && _a !== void 0 ? _a : 0;
        message.y = (_b = object.y) !== null && _b !== void 0 ? _b : 0;
        message.z = (_c = object.z) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseCMsgRGBA() {
    return { r: 0, g: 0, b: 0, a: 0 };
}
exports.CMsgRGBA = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.r !== 0) {
            writer.uint32(8).int32(message.r);
        }
        if (message.g !== 0) {
            writer.uint32(16).int32(message.g);
        }
        if (message.b !== 0) {
            writer.uint32(24).int32(message.b);
        }
        if (message.a !== 0) {
            writer.uint32(32).int32(message.a);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgRGBA();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.r = reader.int32();
                    break;
                case 2:
                    message.g = reader.int32();
                    break;
                case 3:
                    message.b = reader.int32();
                    break;
                case 4:
                    message.a = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCMsgRGBA();
        message.r = (_a = object.r) !== null && _a !== void 0 ? _a : 0;
        message.g = (_b = object.g) !== null && _b !== void 0 ? _b : 0;
        message.b = (_c = object.b) !== null && _c !== void 0 ? _c : 0;
        message.a = (_d = object.a) !== null && _d !== void 0 ? _d : 0;
        return message;
    }
};
function createBaseCNETMsgTick() {
    return {
        tick: 0,
        hostComputationtime: 0,
        hostComputationtimeStdDeviation: 0,
        hostFramestarttimeStdDeviation: 0,
        hltvReplayFlags: 0
    };
}
exports.CNETMsgTick = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.tick !== 0) {
            writer.uint32(8).uint32(message.tick);
        }
        if (message.hostComputationtime !== 0) {
            writer.uint32(32).uint32(message.hostComputationtime);
        }
        if (message.hostComputationtimeStdDeviation !== 0) {
            writer.uint32(40).uint32(message.hostComputationtimeStdDeviation);
        }
        if (message.hostFramestarttimeStdDeviation !== 0) {
            writer.uint32(48).uint32(message.hostFramestarttimeStdDeviation);
        }
        if (message.hltvReplayFlags !== 0) {
            writer.uint32(56).uint32(message.hltvReplayFlags);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCNETMsgTick();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tick = reader.uint32();
                    break;
                case 4:
                    message.hostComputationtime = reader.uint32();
                    break;
                case 5:
                    message.hostComputationtimeStdDeviation = reader.uint32();
                    break;
                case 6:
                    message.hostFramestarttimeStdDeviation = reader.uint32();
                    break;
                case 7:
                    message.hltvReplayFlags = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseCNETMsgTick();
        message.tick = (_a = object.tick) !== null && _a !== void 0 ? _a : 0;
        message.hostComputationtime = (_b = object.hostComputationtime) !== null && _b !== void 0 ? _b : 0;
        message.hostComputationtimeStdDeviation =
            (_c = object.hostComputationtimeStdDeviation) !== null && _c !== void 0 ? _c : 0;
        message.hostFramestarttimeStdDeviation =
            (_d = object.hostFramestarttimeStdDeviation) !== null && _d !== void 0 ? _d : 0;
        message.hltvReplayFlags = (_e = object.hltvReplayFlags) !== null && _e !== void 0 ? _e : 0;
        return message;
    }
};
function createBaseCNETMsgStringCmd() {
    return { command: "" };
}
exports.CNETMsgStringCmd = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.command !== "") {
            writer.uint32(10).string(message.command);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCNETMsgStringCmd();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.command = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCNETMsgStringCmd();
        message.command = (_a = object.command) !== null && _a !== void 0 ? _a : "";
        return message;
    }
};
function createBaseCNETMsgSignonState() {
    return {
        signonState: 0,
        spawnCount: 0,
        numServerPlayers: 0,
        playersNetworkids: [],
        mapName: ""
    };
}
exports.CNETMsgSignonState = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.signonState !== 0) {
            writer.uint32(8).uint32(message.signonState);
        }
        if (message.spawnCount !== 0) {
            writer.uint32(16).uint32(message.spawnCount);
        }
        if (message.numServerPlayers !== 0) {
            writer.uint32(24).uint32(message.numServerPlayers);
        }
        for (const v of message.playersNetworkids) {
            writer.uint32(34).string(v);
        }
        if (message.mapName !== "") {
            writer.uint32(42).string(message.mapName);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCNETMsgSignonState();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.signonState = reader.uint32();
                    break;
                case 2:
                    message.spawnCount = reader.uint32();
                    break;
                case 3:
                    message.numServerPlayers = reader.uint32();
                    break;
                case 4:
                    message.playersNetworkids.push(reader.string());
                    break;
                case 5:
                    message.mapName = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseCNETMsgSignonState();
        message.signonState = (_a = object.signonState) !== null && _a !== void 0 ? _a : 0;
        message.spawnCount = (_b = object.spawnCount) !== null && _b !== void 0 ? _b : 0;
        message.numServerPlayers = (_c = object.numServerPlayers) !== null && _c !== void 0 ? _c : 0;
        message.playersNetworkids = ((_d = object.playersNetworkids) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];
        message.mapName = (_e = object.mapName) !== null && _e !== void 0 ? _e : "";
        return message;
    }
};
function createBaseCMsgCVars() {
    return { cvars: [] };
}
exports.CMsgCVars = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.cvars) {
            exports.CMsgCVars_CVar.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgCVars();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.cvars.push(exports.CMsgCVars_CVar.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCMsgCVars();
        message.cvars = ((_a = object.cvars) === null || _a === void 0 ? void 0 : _a.map(e => exports.CMsgCVars_CVar.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCMsgCVars_CVar() {
    return { name: "", value: "", dictionaryName: 0 };
}
exports.CMsgCVars_CVar = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.name !== "") {
            writer.uint32(10).string(message.name);
        }
        if (message.value !== "") {
            writer.uint32(18).string(message.value);
        }
        if (message.dictionaryName !== 0) {
            writer.uint32(24).uint32(message.dictionaryName);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCMsgCVars_CVar();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.name = reader.string();
                    break;
                case 2:
                    message.value = reader.string();
                    break;
                case 3:
                    message.dictionaryName = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCMsgCVars_CVar();
        message.name = (_a = object.name) !== null && _a !== void 0 ? _a : "";
        message.value = (_b = object.value) !== null && _b !== void 0 ? _b : "";
        message.dictionaryName = (_c = object.dictionaryName) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseCNETMsgSetConVar() {
    return { convars: undefined };
}
exports.CNETMsgSetConVar = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.convars !== undefined) {
            exports.CMsgCVars.encode(message.convars, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCNETMsgSetConVar();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.convars = exports.CMsgCVars.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCNETMsgSetConVar();
        message.convars =
            object.convars !== undefined && object.convars !== null
                ? exports.CMsgCVars.fromPartial(object.convars)
                : undefined;
        return message;
    }
};
function createBaseCNETMsgNOP() {
    return {};
}
exports.CNETMsgNOP = {
    encode(_, writer = minimal_1.Writer.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCNETMsgNOP();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(_) {
        const message = createBaseCNETMsgNOP();
        return message;
    }
};
function createBaseCNETMsgDisconnect() {
    return { text: "" };
}
exports.CNETMsgDisconnect = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.text !== "") {
            writer.uint32(10).string(message.text);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCNETMsgDisconnect();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.text = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCNETMsgDisconnect();
        message.text = (_a = object.text) !== null && _a !== void 0 ? _a : "";
        return message;
    }
};
function createBaseCNETMsgFile() {
    return { transferId: 0, fileName: "", isReplayDemoFile: false, deny: false };
}
exports.CNETMsgFile = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.transferId !== 0) {
            writer.uint32(8).int32(message.transferId);
        }
        if (message.fileName !== "") {
            writer.uint32(18).string(message.fileName);
        }
        if (message.isReplayDemoFile === true) {
            writer.uint32(24).bool(message.isReplayDemoFile);
        }
        if (message.deny === true) {
            writer.uint32(32).bool(message.deny);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCNETMsgFile();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.transferId = reader.int32();
                    break;
                case 2:
                    message.fileName = reader.string();
                    break;
                case 3:
                    message.isReplayDemoFile = reader.bool();
                    break;
                case 4:
                    message.deny = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCNETMsgFile();
        message.transferId = (_a = object.transferId) !== null && _a !== void 0 ? _a : 0;
        message.fileName = (_b = object.fileName) !== null && _b !== void 0 ? _b : "";
        message.isReplayDemoFile = (_c = object.isReplayDemoFile) !== null && _c !== void 0 ? _c : false;
        message.deny = (_d = object.deny) !== null && _d !== void 0 ? _d : false;
        return message;
    }
};
function createBaseCNETMsgSplitScreenUser() {
    return { slot: 0 };
}
exports.CNETMsgSplitScreenUser = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.slot !== 0) {
            writer.uint32(8).int32(message.slot);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCNETMsgSplitScreenUser();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.slot = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCNETMsgSplitScreenUser();
        message.slot = (_a = object.slot) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCNETMsgPlayerAvatarData() {
    return { accountid: 0, rgb: new Uint8Array() };
}
exports.CNETMsgPlayerAvatarData = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.accountid !== 0) {
            writer.uint32(8).uint32(message.accountid);
        }
        if (message.rgb.length !== 0) {
            writer.uint32(18).bytes(message.rgb);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCNETMsgPlayerAvatarData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.accountid = reader.uint32();
                    break;
                case 2:
                    message.rgb = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCNETMsgPlayerAvatarData();
        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;
        message.rgb = (_b = object.rgb) !== null && _b !== void 0 ? _b : new Uint8Array();
        return message;
    }
};
function createBaseCCLCMsgClientInfo() {
    return {
        sendTableCrc: 0,
        serverCount: 0,
        isHltv: false,
        isReplay: false,
        friendsId: 0,
        friendsName: "",
        customFiles: []
    };
}
exports.CCLCMsgClientInfo = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.sendTableCrc !== 0) {
            writer.uint32(13).fixed32(message.sendTableCrc);
        }
        if (message.serverCount !== 0) {
            writer.uint32(16).uint32(message.serverCount);
        }
        if (message.isHltv === true) {
            writer.uint32(24).bool(message.isHltv);
        }
        if (message.isReplay === true) {
            writer.uint32(32).bool(message.isReplay);
        }
        if (message.friendsId !== 0) {
            writer.uint32(40).uint32(message.friendsId);
        }
        if (message.friendsName !== "") {
            writer.uint32(50).string(message.friendsName);
        }
        writer.uint32(58).fork();
        for (const v of message.customFiles) {
            writer.fixed32(v);
        }
        writer.ldelim();
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCLCMsgClientInfo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.sendTableCrc = reader.fixed32();
                    break;
                case 2:
                    message.serverCount = reader.uint32();
                    break;
                case 3:
                    message.isHltv = reader.bool();
                    break;
                case 4:
                    message.isReplay = reader.bool();
                    break;
                case 5:
                    message.friendsId = reader.uint32();
                    break;
                case 6:
                    message.friendsName = reader.string();
                    break;
                case 7:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.customFiles.push(reader.fixed32());
                        }
                    }
                    else {
                        message.customFiles.push(reader.fixed32());
                    }
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g;
        const message = createBaseCCLCMsgClientInfo();
        message.sendTableCrc = (_a = object.sendTableCrc) !== null && _a !== void 0 ? _a : 0;
        message.serverCount = (_b = object.serverCount) !== null && _b !== void 0 ? _b : 0;
        message.isHltv = (_c = object.isHltv) !== null && _c !== void 0 ? _c : false;
        message.isReplay = (_d = object.isReplay) !== null && _d !== void 0 ? _d : false;
        message.friendsId = (_e = object.friendsId) !== null && _e !== void 0 ? _e : 0;
        message.friendsName = (_f = object.friendsName) !== null && _f !== void 0 ? _f : "";
        message.customFiles = ((_g = object.customFiles) === null || _g === void 0 ? void 0 : _g.map(e => e)) || [];
        return message;
    }
};
function createBaseCCLCMsgMove() {
    return { numBackupCommands: 0, numNewCommands: 0, data: new Uint8Array() };
}
exports.CCLCMsgMove = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.numBackupCommands !== 0) {
            writer.uint32(8).uint32(message.numBackupCommands);
        }
        if (message.numNewCommands !== 0) {
            writer.uint32(16).uint32(message.numNewCommands);
        }
        if (message.data.length !== 0) {
            writer.uint32(26).bytes(message.data);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCLCMsgMove();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.numBackupCommands = reader.uint32();
                    break;
                case 2:
                    message.numNewCommands = reader.uint32();
                    break;
                case 3:
                    message.data = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCCLCMsgMove();
        message.numBackupCommands = (_a = object.numBackupCommands) !== null && _a !== void 0 ? _a : 0;
        message.numNewCommands = (_b = object.numNewCommands) !== null && _b !== void 0 ? _b : 0;
        message.data = (_c = object.data) !== null && _c !== void 0 ? _c : new Uint8Array();
        return message;
    }
};
function createBaseCCLCMsgVoiceData() {
    return {
        data: new Uint8Array(),
        xuid: Long.UZERO,
        format: 0,
        sequenceBytes: 0,
        sectionNumber: 0,
        uncompressedSampleOffset: 0
    };
}
exports.CCLCMsgVoiceData = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.data.length !== 0) {
            writer.uint32(10).bytes(message.data);
        }
        if (!message.xuid.isZero()) {
            writer.uint32(17).fixed64(message.xuid);
        }
        if (message.format !== 0) {
            writer.uint32(24).int32(message.format);
        }
        if (message.sequenceBytes !== 0) {
            writer.uint32(32).int32(message.sequenceBytes);
        }
        if (message.sectionNumber !== 0) {
            writer.uint32(40).uint32(message.sectionNumber);
        }
        if (message.uncompressedSampleOffset !== 0) {
            writer.uint32(48).uint32(message.uncompressedSampleOffset);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCLCMsgVoiceData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.data = reader.bytes();
                    break;
                case 2:
                    message.xuid = reader.fixed64();
                    break;
                case 3:
                    message.format = reader.int32();
                    break;
                case 4:
                    message.sequenceBytes = reader.int32();
                    break;
                case 5:
                    message.sectionNumber = reader.uint32();
                    break;
                case 6:
                    message.uncompressedSampleOffset = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseCCLCMsgVoiceData();
        message.data = (_a = object.data) !== null && _a !== void 0 ? _a : new Uint8Array();
        message.xuid =
            object.xuid !== undefined && object.xuid !== null
                ? Long.fromValue(object.xuid)
                : Long.UZERO;
        message.format = (_b = object.format) !== null && _b !== void 0 ? _b : 0;
        message.sequenceBytes = (_c = object.sequenceBytes) !== null && _c !== void 0 ? _c : 0;
        message.sectionNumber = (_d = object.sectionNumber) !== null && _d !== void 0 ? _d : 0;
        message.uncompressedSampleOffset = (_e = object.uncompressedSampleOffset) !== null && _e !== void 0 ? _e : 0;
        return message;
    }
};
function createBaseCCLCMsgBaselineAck() {
    return { baselineTick: 0, baselineNr: 0 };
}
exports.CCLCMsgBaselineAck = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.baselineTick !== 0) {
            writer.uint32(8).int32(message.baselineTick);
        }
        if (message.baselineNr !== 0) {
            writer.uint32(16).int32(message.baselineNr);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCLCMsgBaselineAck();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.baselineTick = reader.int32();
                    break;
                case 2:
                    message.baselineNr = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCCLCMsgBaselineAck();
        message.baselineTick = (_a = object.baselineTick) !== null && _a !== void 0 ? _a : 0;
        message.baselineNr = (_b = object.baselineNr) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCCLCMsgListenEvents() {
    return { eventMask: [] };
}
exports.CCLCMsgListenEvents = {
    encode(message, writer = minimal_1.Writer.create()) {
        writer.uint32(10).fork();
        for (const v of message.eventMask) {
            writer.fixed32(v);
        }
        writer.ldelim();
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCLCMsgListenEvents();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.eventMask.push(reader.fixed32());
                        }
                    }
                    else {
                        message.eventMask.push(reader.fixed32());
                    }
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCLCMsgListenEvents();
        message.eventMask = ((_a = object.eventMask) === null || _a === void 0 ? void 0 : _a.map(e => e)) || [];
        return message;
    }
};
function createBaseCCLCMsgRespondCvarValue() {
    return { cookie: 0, statusCode: 0, name: "", value: "" };
}
exports.CCLCMsgRespondCvarValue = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.cookie !== 0) {
            writer.uint32(8).int32(message.cookie);
        }
        if (message.statusCode !== 0) {
            writer.uint32(16).int32(message.statusCode);
        }
        if (message.name !== "") {
            writer.uint32(26).string(message.name);
        }
        if (message.value !== "") {
            writer.uint32(34).string(message.value);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCLCMsgRespondCvarValue();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.cookie = reader.int32();
                    break;
                case 2:
                    message.statusCode = reader.int32();
                    break;
                case 3:
                    message.name = reader.string();
                    break;
                case 4:
                    message.value = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCCLCMsgRespondCvarValue();
        message.cookie = (_a = object.cookie) !== null && _a !== void 0 ? _a : 0;
        message.statusCode = (_b = object.statusCode) !== null && _b !== void 0 ? _b : 0;
        message.name = (_c = object.name) !== null && _c !== void 0 ? _c : "";
        message.value = (_d = object.value) !== null && _d !== void 0 ? _d : "";
        return message;
    }
};
function createBaseCCLCMsgFileCRCCheck() {
    return {
        codePath: 0,
        path: "",
        codeFilename: 0,
        filename: "",
        fileFraction: 0,
        md5: new Uint8Array(),
        crc: 0,
        fileHashType: 0,
        fileLen: 0,
        packFileId: 0,
        packFileNumber: 0
    };
}
exports.CCLCMsgFileCRCCheck = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.codePath !== 0) {
            writer.uint32(8).int32(message.codePath);
        }
        if (message.path !== "") {
            writer.uint32(18).string(message.path);
        }
        if (message.codeFilename !== 0) {
            writer.uint32(24).int32(message.codeFilename);
        }
        if (message.filename !== "") {
            writer.uint32(34).string(message.filename);
        }
        if (message.fileFraction !== 0) {
            writer.uint32(40).int32(message.fileFraction);
        }
        if (message.md5.length !== 0) {
            writer.uint32(50).bytes(message.md5);
        }
        if (message.crc !== 0) {
            writer.uint32(56).uint32(message.crc);
        }
        if (message.fileHashType !== 0) {
            writer.uint32(64).int32(message.fileHashType);
        }
        if (message.fileLen !== 0) {
            writer.uint32(72).int32(message.fileLen);
        }
        if (message.packFileId !== 0) {
            writer.uint32(80).int32(message.packFileId);
        }
        if (message.packFileNumber !== 0) {
            writer.uint32(88).int32(message.packFileNumber);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCLCMsgFileCRCCheck();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.codePath = reader.int32();
                    break;
                case 2:
                    message.path = reader.string();
                    break;
                case 3:
                    message.codeFilename = reader.int32();
                    break;
                case 4:
                    message.filename = reader.string();
                    break;
                case 5:
                    message.fileFraction = reader.int32();
                    break;
                case 6:
                    message.md5 = reader.bytes();
                    break;
                case 7:
                    message.crc = reader.uint32();
                    break;
                case 8:
                    message.fileHashType = reader.int32();
                    break;
                case 9:
                    message.fileLen = reader.int32();
                    break;
                case 10:
                    message.packFileId = reader.int32();
                    break;
                case 11:
                    message.packFileNumber = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
        const message = createBaseCCLCMsgFileCRCCheck();
        message.codePath = (_a = object.codePath) !== null && _a !== void 0 ? _a : 0;
        message.path = (_b = object.path) !== null && _b !== void 0 ? _b : "";
        message.codeFilename = (_c = object.codeFilename) !== null && _c !== void 0 ? _c : 0;
        message.filename = (_d = object.filename) !== null && _d !== void 0 ? _d : "";
        message.fileFraction = (_e = object.fileFraction) !== null && _e !== void 0 ? _e : 0;
        message.md5 = (_f = object.md5) !== null && _f !== void 0 ? _f : new Uint8Array();
        message.crc = (_g = object.crc) !== null && _g !== void 0 ? _g : 0;
        message.fileHashType = (_h = object.fileHashType) !== null && _h !== void 0 ? _h : 0;
        message.fileLen = (_j = object.fileLen) !== null && _j !== void 0 ? _j : 0;
        message.packFileId = (_k = object.packFileId) !== null && _k !== void 0 ? _k : 0;
        message.packFileNumber = (_l = object.packFileNumber) !== null && _l !== void 0 ? _l : 0;
        return message;
    }
};
function createBaseCCLCMsgLoadingProgress() {
    return { progress: 0 };
}
exports.CCLCMsgLoadingProgress = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.progress !== 0) {
            writer.uint32(8).int32(message.progress);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCLCMsgLoadingProgress();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.progress = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCLCMsgLoadingProgress();
        message.progress = (_a = object.progress) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCCLCMsgSplitPlayerConnect() {
    return { convars: undefined };
}
exports.CCLCMsgSplitPlayerConnect = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.convars !== undefined) {
            exports.CMsgCVars.encode(message.convars, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCLCMsgSplitPlayerConnect();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.convars = exports.CMsgCVars.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCCLCMsgSplitPlayerConnect();
        message.convars =
            object.convars !== undefined && object.convars !== null
                ? exports.CMsgCVars.fromPartial(object.convars)
                : undefined;
        return message;
    }
};
function createBaseCCLCMsgCmdKeyValues() {
    return { keyvalues: new Uint8Array() };
}
exports.CCLCMsgCmdKeyValues = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.keyvalues.length !== 0) {
            writer.uint32(10).bytes(message.keyvalues);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCLCMsgCmdKeyValues();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.keyvalues = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCCLCMsgCmdKeyValues();
        message.keyvalues = (_a = object.keyvalues) !== null && _a !== void 0 ? _a : new Uint8Array();
        return message;
    }
};
function createBaseCSVCMsgServerInfo() {
    return {
        protocol: 0,
        serverCount: 0,
        isDedicated: false,
        isOfficialValveServer: false,
        isHltv: false,
        isReplay: false,
        isRedirectingToProxyRelay: false,
        cOs: 0,
        mapCrc: 0,
        clientCrc: 0,
        stringTableCrc: 0,
        maxClients: 0,
        maxClasses: 0,
        playerSlot: 0,
        tickInterval: 0,
        gameDir: "",
        mapName: "",
        mapGroupName: "",
        skyName: "",
        hostName: "",
        publicIp: 0,
        ugcMapId: Long.UZERO
    };
}
exports.CSVCMsgServerInfo = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.protocol !== 0) {
            writer.uint32(8).int32(message.protocol);
        }
        if (message.serverCount !== 0) {
            writer.uint32(16).int32(message.serverCount);
        }
        if (message.isDedicated === true) {
            writer.uint32(24).bool(message.isDedicated);
        }
        if (message.isOfficialValveServer === true) {
            writer.uint32(32).bool(message.isOfficialValveServer);
        }
        if (message.isHltv === true) {
            writer.uint32(40).bool(message.isHltv);
        }
        if (message.isReplay === true) {
            writer.uint32(48).bool(message.isReplay);
        }
        if (message.isRedirectingToProxyRelay === true) {
            writer.uint32(168).bool(message.isRedirectingToProxyRelay);
        }
        if (message.cOs !== 0) {
            writer.uint32(56).int32(message.cOs);
        }
        if (message.mapCrc !== 0) {
            writer.uint32(69).fixed32(message.mapCrc);
        }
        if (message.clientCrc !== 0) {
            writer.uint32(77).fixed32(message.clientCrc);
        }
        if (message.stringTableCrc !== 0) {
            writer.uint32(85).fixed32(message.stringTableCrc);
        }
        if (message.maxClients !== 0) {
            writer.uint32(88).int32(message.maxClients);
        }
        if (message.maxClasses !== 0) {
            writer.uint32(96).int32(message.maxClasses);
        }
        if (message.playerSlot !== 0) {
            writer.uint32(104).int32(message.playerSlot);
        }
        if (message.tickInterval !== 0) {
            writer.uint32(117).float(message.tickInterval);
        }
        if (message.gameDir !== "") {
            writer.uint32(122).string(message.gameDir);
        }
        if (message.mapName !== "") {
            writer.uint32(130).string(message.mapName);
        }
        if (message.mapGroupName !== "") {
            writer.uint32(138).string(message.mapGroupName);
        }
        if (message.skyName !== "") {
            writer.uint32(146).string(message.skyName);
        }
        if (message.hostName !== "") {
            writer.uint32(154).string(message.hostName);
        }
        if (message.publicIp !== 0) {
            writer.uint32(160).uint32(message.publicIp);
        }
        if (!message.ugcMapId.isZero()) {
            writer.uint32(176).uint64(message.ugcMapId);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgServerInfo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.protocol = reader.int32();
                    break;
                case 2:
                    message.serverCount = reader.int32();
                    break;
                case 3:
                    message.isDedicated = reader.bool();
                    break;
                case 4:
                    message.isOfficialValveServer = reader.bool();
                    break;
                case 5:
                    message.isHltv = reader.bool();
                    break;
                case 6:
                    message.isReplay = reader.bool();
                    break;
                case 21:
                    message.isRedirectingToProxyRelay = reader.bool();
                    break;
                case 7:
                    message.cOs = reader.int32();
                    break;
                case 8:
                    message.mapCrc = reader.fixed32();
                    break;
                case 9:
                    message.clientCrc = reader.fixed32();
                    break;
                case 10:
                    message.stringTableCrc = reader.fixed32();
                    break;
                case 11:
                    message.maxClients = reader.int32();
                    break;
                case 12:
                    message.maxClasses = reader.int32();
                    break;
                case 13:
                    message.playerSlot = reader.int32();
                    break;
                case 14:
                    message.tickInterval = reader.float();
                    break;
                case 15:
                    message.gameDir = reader.string();
                    break;
                case 16:
                    message.mapName = reader.string();
                    break;
                case 17:
                    message.mapGroupName = reader.string();
                    break;
                case 18:
                    message.skyName = reader.string();
                    break;
                case 19:
                    message.hostName = reader.string();
                    break;
                case 20:
                    message.publicIp = reader.uint32();
                    break;
                case 22:
                    message.ugcMapId = reader.uint64();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
        const message = createBaseCSVCMsgServerInfo();
        message.protocol = (_a = object.protocol) !== null && _a !== void 0 ? _a : 0;
        message.serverCount = (_b = object.serverCount) !== null && _b !== void 0 ? _b : 0;
        message.isDedicated = (_c = object.isDedicated) !== null && _c !== void 0 ? _c : false;
        message.isOfficialValveServer = (_d = object.isOfficialValveServer) !== null && _d !== void 0 ? _d : false;
        message.isHltv = (_e = object.isHltv) !== null && _e !== void 0 ? _e : false;
        message.isReplay = (_f = object.isReplay) !== null && _f !== void 0 ? _f : false;
        message.isRedirectingToProxyRelay =
            (_g = object.isRedirectingToProxyRelay) !== null && _g !== void 0 ? _g : false;
        message.cOs = (_h = object.cOs) !== null && _h !== void 0 ? _h : 0;
        message.mapCrc = (_j = object.mapCrc) !== null && _j !== void 0 ? _j : 0;
        message.clientCrc = (_k = object.clientCrc) !== null && _k !== void 0 ? _k : 0;
        message.stringTableCrc = (_l = object.stringTableCrc) !== null && _l !== void 0 ? _l : 0;
        message.maxClients = (_m = object.maxClients) !== null && _m !== void 0 ? _m : 0;
        message.maxClasses = (_o = object.maxClasses) !== null && _o !== void 0 ? _o : 0;
        message.playerSlot = (_p = object.playerSlot) !== null && _p !== void 0 ? _p : 0;
        message.tickInterval = (_q = object.tickInterval) !== null && _q !== void 0 ? _q : 0;
        message.gameDir = (_r = object.gameDir) !== null && _r !== void 0 ? _r : "";
        message.mapName = (_s = object.mapName) !== null && _s !== void 0 ? _s : "";
        message.mapGroupName = (_t = object.mapGroupName) !== null && _t !== void 0 ? _t : "";
        message.skyName = (_u = object.skyName) !== null && _u !== void 0 ? _u : "";
        message.hostName = (_v = object.hostName) !== null && _v !== void 0 ? _v : "";
        message.publicIp = (_w = object.publicIp) !== null && _w !== void 0 ? _w : 0;
        message.ugcMapId =
            object.ugcMapId !== undefined && object.ugcMapId !== null
                ? Long.fromValue(object.ugcMapId)
                : Long.UZERO;
        return message;
    }
};
function createBaseCSVCMsgClassInfo() {
    return { createOnClient: false, classes: [] };
}
exports.CSVCMsgClassInfo = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.createOnClient === true) {
            writer.uint32(8).bool(message.createOnClient);
        }
        for (const v of message.classes) {
            exports.CSVCMsgClassInfo_classT.encode(v, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgClassInfo();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.createOnClient = reader.bool();
                    break;
                case 2:
                    message.classes.push(exports.CSVCMsgClassInfo_classT.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCSVCMsgClassInfo();
        message.createOnClient = (_a = object.createOnClient) !== null && _a !== void 0 ? _a : false;
        message.classes =
            ((_b = object.classes) === null || _b === void 0 ? void 0 : _b.map(e => exports.CSVCMsgClassInfo_classT.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCSVCMsgClassInfo_classT() {
    return { classId: 0, dataTableName: "", className: "" };
}
exports.CSVCMsgClassInfo_classT = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.classId !== 0) {
            writer.uint32(8).int32(message.classId);
        }
        if (message.dataTableName !== "") {
            writer.uint32(18).string(message.dataTableName);
        }
        if (message.className !== "") {
            writer.uint32(26).string(message.className);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgClassInfo_classT();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.classId = reader.int32();
                    break;
                case 2:
                    message.dataTableName = reader.string();
                    break;
                case 3:
                    message.className = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCSVCMsgClassInfo_classT();
        message.classId = (_a = object.classId) !== null && _a !== void 0 ? _a : 0;
        message.dataTableName = (_b = object.dataTableName) !== null && _b !== void 0 ? _b : "";
        message.className = (_c = object.className) !== null && _c !== void 0 ? _c : "";
        return message;
    }
};
function createBaseCSVCMsgSendTable() {
    return { isEnd: false, netTableName: "", needsDecoder: false, props: [] };
}
exports.CSVCMsgSendTable = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.isEnd === true) {
            writer.uint32(8).bool(message.isEnd);
        }
        if (message.netTableName !== "") {
            writer.uint32(18).string(message.netTableName);
        }
        if (message.needsDecoder === true) {
            writer.uint32(24).bool(message.needsDecoder);
        }
        for (const v of message.props) {
            exports.CSVCMsgSendTable_sendpropT.encode(v, writer.uint32(34).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgSendTable();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.isEnd = reader.bool();
                    break;
                case 2:
                    message.netTableName = reader.string();
                    break;
                case 3:
                    message.needsDecoder = reader.bool();
                    break;
                case 4:
                    message.props.push(exports.CSVCMsgSendTable_sendpropT.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCSVCMsgSendTable();
        message.isEnd = (_a = object.isEnd) !== null && _a !== void 0 ? _a : false;
        message.netTableName = (_b = object.netTableName) !== null && _b !== void 0 ? _b : "";
        message.needsDecoder = (_c = object.needsDecoder) !== null && _c !== void 0 ? _c : false;
        message.props =
            ((_d = object.props) === null || _d === void 0 ? void 0 : _d.map(e => exports.CSVCMsgSendTable_sendpropT.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCSVCMsgSendTable_sendpropT() {
    return {
        type: 0,
        varName: "",
        flags: 0,
        priority: 0,
        dtName: "",
        numElements: 0,
        lowValue: 0,
        highValue: 0,
        numBits: 0
    };
}
exports.CSVCMsgSendTable_sendpropT = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.type !== 0) {
            writer.uint32(8).int32(message.type);
        }
        if (message.varName !== "") {
            writer.uint32(18).string(message.varName);
        }
        if (message.flags !== 0) {
            writer.uint32(24).int32(message.flags);
        }
        if (message.priority !== 0) {
            writer.uint32(32).int32(message.priority);
        }
        if (message.dtName !== "") {
            writer.uint32(42).string(message.dtName);
        }
        if (message.numElements !== 0) {
            writer.uint32(48).int32(message.numElements);
        }
        if (message.lowValue !== 0) {
            writer.uint32(61).float(message.lowValue);
        }
        if (message.highValue !== 0) {
            writer.uint32(69).float(message.highValue);
        }
        if (message.numBits !== 0) {
            writer.uint32(72).int32(message.numBits);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgSendTable_sendpropT();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.type = reader.int32();
                    break;
                case 2:
                    message.varName = reader.string();
                    break;
                case 3:
                    message.flags = reader.int32();
                    break;
                case 4:
                    message.priority = reader.int32();
                    break;
                case 5:
                    message.dtName = reader.string();
                    break;
                case 6:
                    message.numElements = reader.int32();
                    break;
                case 7:
                    message.lowValue = reader.float();
                    break;
                case 8:
                    message.highValue = reader.float();
                    break;
                case 9:
                    message.numBits = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
        const message = createBaseCSVCMsgSendTable_sendpropT();
        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;
        message.varName = (_b = object.varName) !== null && _b !== void 0 ? _b : "";
        message.flags = (_c = object.flags) !== null && _c !== void 0 ? _c : 0;
        message.priority = (_d = object.priority) !== null && _d !== void 0 ? _d : 0;
        message.dtName = (_e = object.dtName) !== null && _e !== void 0 ? _e : "";
        message.numElements = (_f = object.numElements) !== null && _f !== void 0 ? _f : 0;
        message.lowValue = (_g = object.lowValue) !== null && _g !== void 0 ? _g : 0;
        message.highValue = (_h = object.highValue) !== null && _h !== void 0 ? _h : 0;
        message.numBits = (_j = object.numBits) !== null && _j !== void 0 ? _j : 0;
        return message;
    }
};
function createBaseCSVCMsgPrint() {
    return { text: "" };
}
exports.CSVCMsgPrint = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.text !== "") {
            writer.uint32(10).string(message.text);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgPrint();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.text = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCSVCMsgPrint();
        message.text = (_a = object.text) !== null && _a !== void 0 ? _a : "";
        return message;
    }
};
function createBaseCSVCMsgSetPause() {
    return { paused: false };
}
exports.CSVCMsgSetPause = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.paused === true) {
            writer.uint32(8).bool(message.paused);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgSetPause();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.paused = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCSVCMsgSetPause();
        message.paused = (_a = object.paused) !== null && _a !== void 0 ? _a : false;
        return message;
    }
};
function createBaseCSVCMsgSetView() {
    return { entityIndex: 0 };
}
exports.CSVCMsgSetView = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.entityIndex !== 0) {
            writer.uint32(8).int32(message.entityIndex);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgSetView();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.entityIndex = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCSVCMsgSetView();
        message.entityIndex = (_a = object.entityIndex) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCSVCMsgCreateStringTable() {
    return {
        name: "",
        maxEntries: 0,
        numEntries: 0,
        userDataFixedSize: false,
        userDataSize: 0,
        userDataSizeBits: 0,
        flags: 0,
        stringData: new Uint8Array()
    };
}
exports.CSVCMsgCreateStringTable = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.name !== "") {
            writer.uint32(10).string(message.name);
        }
        if (message.maxEntries !== 0) {
            writer.uint32(16).int32(message.maxEntries);
        }
        if (message.numEntries !== 0) {
            writer.uint32(24).int32(message.numEntries);
        }
        if (message.userDataFixedSize === true) {
            writer.uint32(32).bool(message.userDataFixedSize);
        }
        if (message.userDataSize !== 0) {
            writer.uint32(40).int32(message.userDataSize);
        }
        if (message.userDataSizeBits !== 0) {
            writer.uint32(48).int32(message.userDataSizeBits);
        }
        if (message.flags !== 0) {
            writer.uint32(56).int32(message.flags);
        }
        if (message.stringData.length !== 0) {
            writer.uint32(66).bytes(message.stringData);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgCreateStringTable();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.name = reader.string();
                    break;
                case 2:
                    message.maxEntries = reader.int32();
                    break;
                case 3:
                    message.numEntries = reader.int32();
                    break;
                case 4:
                    message.userDataFixedSize = reader.bool();
                    break;
                case 5:
                    message.userDataSize = reader.int32();
                    break;
                case 6:
                    message.userDataSizeBits = reader.int32();
                    break;
                case 7:
                    message.flags = reader.int32();
                    break;
                case 8:
                    message.stringData = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h;
        const message = createBaseCSVCMsgCreateStringTable();
        message.name = (_a = object.name) !== null && _a !== void 0 ? _a : "";
        message.maxEntries = (_b = object.maxEntries) !== null && _b !== void 0 ? _b : 0;
        message.numEntries = (_c = object.numEntries) !== null && _c !== void 0 ? _c : 0;
        message.userDataFixedSize = (_d = object.userDataFixedSize) !== null && _d !== void 0 ? _d : false;
        message.userDataSize = (_e = object.userDataSize) !== null && _e !== void 0 ? _e : 0;
        message.userDataSizeBits = (_f = object.userDataSizeBits) !== null && _f !== void 0 ? _f : 0;
        message.flags = (_g = object.flags) !== null && _g !== void 0 ? _g : 0;
        message.stringData = (_h = object.stringData) !== null && _h !== void 0 ? _h : new Uint8Array();
        return message;
    }
};
function createBaseCSVCMsgUpdateStringTable() {
    return { tableId: 0, numChangedEntries: 0, stringData: new Uint8Array() };
}
exports.CSVCMsgUpdateStringTable = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.tableId !== 0) {
            writer.uint32(8).int32(message.tableId);
        }
        if (message.numChangedEntries !== 0) {
            writer.uint32(16).int32(message.numChangedEntries);
        }
        if (message.stringData.length !== 0) {
            writer.uint32(26).bytes(message.stringData);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgUpdateStringTable();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tableId = reader.int32();
                    break;
                case 2:
                    message.numChangedEntries = reader.int32();
                    break;
                case 3:
                    message.stringData = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCSVCMsgUpdateStringTable();
        message.tableId = (_a = object.tableId) !== null && _a !== void 0 ? _a : 0;
        message.numChangedEntries = (_b = object.numChangedEntries) !== null && _b !== void 0 ? _b : 0;
        message.stringData = (_c = object.stringData) !== null && _c !== void 0 ? _c : new Uint8Array();
        return message;
    }
};
function createBaseCSVCMsgVoiceInit() {
    return { quality: 0, codec: "", version: 0 };
}
exports.CSVCMsgVoiceInit = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.quality !== 0) {
            writer.uint32(8).int32(message.quality);
        }
        if (message.codec !== "") {
            writer.uint32(18).string(message.codec);
        }
        if (message.version !== 0) {
            writer.uint32(24).int32(message.version);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgVoiceInit();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.quality = reader.int32();
                    break;
                case 2:
                    message.codec = reader.string();
                    break;
                case 3:
                    message.version = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCSVCMsgVoiceInit();
        message.quality = (_a = object.quality) !== null && _a !== void 0 ? _a : 0;
        message.codec = (_b = object.codec) !== null && _b !== void 0 ? _b : "";
        message.version = (_c = object.version) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseCSVCMsgVoiceData() {
    return {
        client: 0,
        proximity: false,
        xuid: Long.UZERO,
        audibleMask: 0,
        voiceData: new Uint8Array(),
        caster: false,
        format: 0,
        sequenceBytes: 0,
        sectionNumber: 0,
        uncompressedSampleOffset: 0
    };
}
exports.CSVCMsgVoiceData = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.client !== 0) {
            writer.uint32(8).int32(message.client);
        }
        if (message.proximity === true) {
            writer.uint32(16).bool(message.proximity);
        }
        if (!message.xuid.isZero()) {
            writer.uint32(25).fixed64(message.xuid);
        }
        if (message.audibleMask !== 0) {
            writer.uint32(32).int32(message.audibleMask);
        }
        if (message.voiceData.length !== 0) {
            writer.uint32(42).bytes(message.voiceData);
        }
        if (message.caster === true) {
            writer.uint32(48).bool(message.caster);
        }
        if (message.format !== 0) {
            writer.uint32(56).int32(message.format);
        }
        if (message.sequenceBytes !== 0) {
            writer.uint32(64).int32(message.sequenceBytes);
        }
        if (message.sectionNumber !== 0) {
            writer.uint32(72).uint32(message.sectionNumber);
        }
        if (message.uncompressedSampleOffset !== 0) {
            writer.uint32(80).uint32(message.uncompressedSampleOffset);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgVoiceData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.client = reader.int32();
                    break;
                case 2:
                    message.proximity = reader.bool();
                    break;
                case 3:
                    message.xuid = reader.fixed64();
                    break;
                case 4:
                    message.audibleMask = reader.int32();
                    break;
                case 5:
                    message.voiceData = reader.bytes();
                    break;
                case 6:
                    message.caster = reader.bool();
                    break;
                case 7:
                    message.format = reader.int32();
                    break;
                case 8:
                    message.sequenceBytes = reader.int32();
                    break;
                case 9:
                    message.sectionNumber = reader.uint32();
                    break;
                case 10:
                    message.uncompressedSampleOffset = reader.uint32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
        const message = createBaseCSVCMsgVoiceData();
        message.client = (_a = object.client) !== null && _a !== void 0 ? _a : 0;
        message.proximity = (_b = object.proximity) !== null && _b !== void 0 ? _b : false;
        message.xuid =
            object.xuid !== undefined && object.xuid !== null
                ? Long.fromValue(object.xuid)
                : Long.UZERO;
        message.audibleMask = (_c = object.audibleMask) !== null && _c !== void 0 ? _c : 0;
        message.voiceData = (_d = object.voiceData) !== null && _d !== void 0 ? _d : new Uint8Array();
        message.caster = (_e = object.caster) !== null && _e !== void 0 ? _e : false;
        message.format = (_f = object.format) !== null && _f !== void 0 ? _f : 0;
        message.sequenceBytes = (_g = object.sequenceBytes) !== null && _g !== void 0 ? _g : 0;
        message.sectionNumber = (_h = object.sectionNumber) !== null && _h !== void 0 ? _h : 0;
        message.uncompressedSampleOffset = (_j = object.uncompressedSampleOffset) !== null && _j !== void 0 ? _j : 0;
        return message;
    }
};
function createBaseCSVCMsgFixAngle() {
    return { relative: false, angle: undefined };
}
exports.CSVCMsgFixAngle = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.relative === true) {
            writer.uint32(8).bool(message.relative);
        }
        if (message.angle !== undefined) {
            exports.CMsgQAngle.encode(message.angle, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgFixAngle();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.relative = reader.bool();
                    break;
                case 2:
                    message.angle = exports.CMsgQAngle.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCSVCMsgFixAngle();
        message.relative = (_a = object.relative) !== null && _a !== void 0 ? _a : false;
        message.angle =
            object.angle !== undefined && object.angle !== null
                ? exports.CMsgQAngle.fromPartial(object.angle)
                : undefined;
        return message;
    }
};
function createBaseCSVCMsgCrosshairAngle() {
    return { angle: undefined };
}
exports.CSVCMsgCrosshairAngle = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.angle !== undefined) {
            exports.CMsgQAngle.encode(message.angle, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgCrosshairAngle();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.angle = exports.CMsgQAngle.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        const message = createBaseCSVCMsgCrosshairAngle();
        message.angle =
            object.angle !== undefined && object.angle !== null
                ? exports.CMsgQAngle.fromPartial(object.angle)
                : undefined;
        return message;
    }
};
function createBaseCSVCMsgPrefetch() {
    return { soundIndex: 0 };
}
exports.CSVCMsgPrefetch = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.soundIndex !== 0) {
            writer.uint32(8).int32(message.soundIndex);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgPrefetch();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.soundIndex = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCSVCMsgPrefetch();
        message.soundIndex = (_a = object.soundIndex) !== null && _a !== void 0 ? _a : 0;
        return message;
    }
};
function createBaseCSVCMsgBSPDecal() {
    return {
        pos: undefined,
        decalTextureIndex: 0,
        entityIndex: 0,
        modelIndex: 0,
        lowPriority: false
    };
}
exports.CSVCMsgBSPDecal = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.pos !== undefined) {
            exports.CMsgVector.encode(message.pos, writer.uint32(10).fork()).ldelim();
        }
        if (message.decalTextureIndex !== 0) {
            writer.uint32(16).int32(message.decalTextureIndex);
        }
        if (message.entityIndex !== 0) {
            writer.uint32(24).int32(message.entityIndex);
        }
        if (message.modelIndex !== 0) {
            writer.uint32(32).int32(message.modelIndex);
        }
        if (message.lowPriority === true) {
            writer.uint32(40).bool(message.lowPriority);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgBSPDecal();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.pos = exports.CMsgVector.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.decalTextureIndex = reader.int32();
                    break;
                case 3:
                    message.entityIndex = reader.int32();
                    break;
                case 4:
                    message.modelIndex = reader.int32();
                    break;
                case 5:
                    message.lowPriority = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCSVCMsgBSPDecal();
        message.pos =
            object.pos !== undefined && object.pos !== null
                ? exports.CMsgVector.fromPartial(object.pos)
                : undefined;
        message.decalTextureIndex = (_a = object.decalTextureIndex) !== null && _a !== void 0 ? _a : 0;
        message.entityIndex = (_b = object.entityIndex) !== null && _b !== void 0 ? _b : 0;
        message.modelIndex = (_c = object.modelIndex) !== null && _c !== void 0 ? _c : 0;
        message.lowPriority = (_d = object.lowPriority) !== null && _d !== void 0 ? _d : false;
        return message;
    }
};
function createBaseCSVCMsgSplitScreen() {
    return { type: 0, slot: 0, playerIndex: 0 };
}
exports.CSVCMsgSplitScreen = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.type !== 0) {
            writer.uint32(8).int32(message.type);
        }
        if (message.slot !== 0) {
            writer.uint32(16).int32(message.slot);
        }
        if (message.playerIndex !== 0) {
            writer.uint32(24).int32(message.playerIndex);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgSplitScreen();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.type = reader.int32();
                    break;
                case 2:
                    message.slot = reader.int32();
                    break;
                case 3:
                    message.playerIndex = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCSVCMsgSplitScreen();
        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;
        message.slot = (_b = object.slot) !== null && _b !== void 0 ? _b : 0;
        message.playerIndex = (_c = object.playerIndex) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseCSVCMsgGetCvarValue() {
    return { cookie: 0, cvarName: "" };
}
exports.CSVCMsgGetCvarValue = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.cookie !== 0) {
            writer.uint32(8).int32(message.cookie);
        }
        if (message.cvarName !== "") {
            writer.uint32(18).string(message.cvarName);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgGetCvarValue();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.cookie = reader.int32();
                    break;
                case 2:
                    message.cvarName = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCSVCMsgGetCvarValue();
        message.cookie = (_a = object.cookie) !== null && _a !== void 0 ? _a : 0;
        message.cvarName = (_b = object.cvarName) !== null && _b !== void 0 ? _b : "";
        return message;
    }
};
function createBaseCSVCMsgMenu() {
    return { dialogType: 0, menuKeyValues: new Uint8Array() };
}
exports.CSVCMsgMenu = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.dialogType !== 0) {
            writer.uint32(8).int32(message.dialogType);
        }
        if (message.menuKeyValues.length !== 0) {
            writer.uint32(18).bytes(message.menuKeyValues);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgMenu();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.dialogType = reader.int32();
                    break;
                case 2:
                    message.menuKeyValues = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCSVCMsgMenu();
        message.dialogType = (_a = object.dialogType) !== null && _a !== void 0 ? _a : 0;
        message.menuKeyValues = (_b = object.menuKeyValues) !== null && _b !== void 0 ? _b : new Uint8Array();
        return message;
    }
};
function createBaseCSVCMsgUserMessage() {
    return { msgType: 0, msgData: new Uint8Array(), passthrough: 0 };
}
exports.CSVCMsgUserMessage = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.msgType !== 0) {
            writer.uint32(8).int32(message.msgType);
        }
        if (message.msgData.length !== 0) {
            writer.uint32(18).bytes(message.msgData);
        }
        if (message.passthrough !== 0) {
            writer.uint32(24).int32(message.passthrough);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgUserMessage();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.msgType = reader.int32();
                    break;
                case 2:
                    message.msgData = reader.bytes();
                    break;
                case 3:
                    message.passthrough = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCSVCMsgUserMessage();
        message.msgType = (_a = object.msgType) !== null && _a !== void 0 ? _a : 0;
        message.msgData = (_b = object.msgData) !== null && _b !== void 0 ? _b : new Uint8Array();
        message.passthrough = (_c = object.passthrough) !== null && _c !== void 0 ? _c : 0;
        return message;
    }
};
function createBaseCSVCMsgPaintmapData() {
    return { paintmap: new Uint8Array() };
}
exports.CSVCMsgPaintmapData = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.paintmap.length !== 0) {
            writer.uint32(10).bytes(message.paintmap);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgPaintmapData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.paintmap = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCSVCMsgPaintmapData();
        message.paintmap = (_a = object.paintmap) !== null && _a !== void 0 ? _a : new Uint8Array();
        return message;
    }
};
function createBaseCSVCMsgGameEvent() {
    return { eventName: "", eventid: 0, keys: [], passthrough: 0 };
}
exports.CSVCMsgGameEvent = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.eventName !== "") {
            writer.uint32(10).string(message.eventName);
        }
        if (message.eventid !== 0) {
            writer.uint32(16).int32(message.eventid);
        }
        for (const v of message.keys) {
            exports.CSVCMsgGameEvent_keyT.encode(v, writer.uint32(26).fork()).ldelim();
        }
        if (message.passthrough !== 0) {
            writer.uint32(32).int32(message.passthrough);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgGameEvent();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.eventName = reader.string();
                    break;
                case 2:
                    message.eventid = reader.int32();
                    break;
                case 3:
                    message.keys.push(exports.CSVCMsgGameEvent_keyT.decode(reader, reader.uint32()));
                    break;
                case 4:
                    message.passthrough = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseCSVCMsgGameEvent();
        message.eventName = (_a = object.eventName) !== null && _a !== void 0 ? _a : "";
        message.eventid = (_b = object.eventid) !== null && _b !== void 0 ? _b : 0;
        message.keys =
            ((_c = object.keys) === null || _c === void 0 ? void 0 : _c.map(e => exports.CSVCMsgGameEvent_keyT.fromPartial(e))) || [];
        message.passthrough = (_d = object.passthrough) !== null && _d !== void 0 ? _d : 0;
        return message;
    }
};
function createBaseCSVCMsgGameEvent_keyT() {
    return {
        type: 0,
        valString: "",
        valFloat: 0,
        valLong: 0,
        valShort: 0,
        valByte: 0,
        valBool: false,
        valUint64: Long.UZERO,
        valWstring: new Uint8Array()
    };
}
exports.CSVCMsgGameEvent_keyT = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.type !== 0) {
            writer.uint32(8).int32(message.type);
        }
        if (message.valString !== "") {
            writer.uint32(18).string(message.valString);
        }
        if (message.valFloat !== 0) {
            writer.uint32(29).float(message.valFloat);
        }
        if (message.valLong !== 0) {
            writer.uint32(32).int32(message.valLong);
        }
        if (message.valShort !== 0) {
            writer.uint32(40).int32(message.valShort);
        }
        if (message.valByte !== 0) {
            writer.uint32(48).int32(message.valByte);
        }
        if (message.valBool === true) {
            writer.uint32(56).bool(message.valBool);
        }
        if (!message.valUint64.isZero()) {
            writer.uint32(64).uint64(message.valUint64);
        }
        if (message.valWstring.length !== 0) {
            writer.uint32(74).bytes(message.valWstring);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgGameEvent_keyT();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.type = reader.int32();
                    break;
                case 2:
                    message.valString = reader.string();
                    break;
                case 3:
                    message.valFloat = reader.float();
                    break;
                case 4:
                    message.valLong = reader.int32();
                    break;
                case 5:
                    message.valShort = reader.int32();
                    break;
                case 6:
                    message.valByte = reader.int32();
                    break;
                case 7:
                    message.valBool = reader.bool();
                    break;
                case 8:
                    message.valUint64 = reader.uint64();
                    break;
                case 9:
                    message.valWstring = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h;
        const message = createBaseCSVCMsgGameEvent_keyT();
        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;
        message.valString = (_b = object.valString) !== null && _b !== void 0 ? _b : "";
        message.valFloat = (_c = object.valFloat) !== null && _c !== void 0 ? _c : 0;
        message.valLong = (_d = object.valLong) !== null && _d !== void 0 ? _d : 0;
        message.valShort = (_e = object.valShort) !== null && _e !== void 0 ? _e : 0;
        message.valByte = (_f = object.valByte) !== null && _f !== void 0 ? _f : 0;
        message.valBool = (_g = object.valBool) !== null && _g !== void 0 ? _g : false;
        message.valUint64 =
            object.valUint64 !== undefined && object.valUint64 !== null
                ? Long.fromValue(object.valUint64)
                : Long.UZERO;
        message.valWstring = (_h = object.valWstring) !== null && _h !== void 0 ? _h : new Uint8Array();
        return message;
    }
};
function createBaseCSVCMsgGameEventList() {
    return { descriptors: [] };
}
exports.CSVCMsgGameEventList = {
    encode(message, writer = minimal_1.Writer.create()) {
        for (const v of message.descriptors) {
            exports.CSVCMsgGameEventList_descriptorT.encode(v, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgGameEventList();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.descriptors.push(exports.CSVCMsgGameEventList_descriptorT.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCSVCMsgGameEventList();
        message.descriptors =
            ((_a = object.descriptors) === null || _a === void 0 ? void 0 : _a.map(e => exports.CSVCMsgGameEventList_descriptorT.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCSVCMsgGameEventList_keyT() {
    return { type: 0, name: "" };
}
exports.CSVCMsgGameEventList_keyT = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.type !== 0) {
            writer.uint32(8).int32(message.type);
        }
        if (message.name !== "") {
            writer.uint32(18).string(message.name);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgGameEventList_keyT();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.type = reader.int32();
                    break;
                case 2:
                    message.name = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCSVCMsgGameEventList_keyT();
        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;
        message.name = (_b = object.name) !== null && _b !== void 0 ? _b : "";
        return message;
    }
};
function createBaseCSVCMsgGameEventList_descriptorT() {
    return { eventid: 0, name: "", keys: [] };
}
exports.CSVCMsgGameEventList_descriptorT = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.eventid !== 0) {
            writer.uint32(8).int32(message.eventid);
        }
        if (message.name !== "") {
            writer.uint32(18).string(message.name);
        }
        for (const v of message.keys) {
            exports.CSVCMsgGameEventList_keyT.encode(v, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgGameEventList_descriptorT();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.eventid = reader.int32();
                    break;
                case 2:
                    message.name = reader.string();
                    break;
                case 3:
                    message.keys.push(exports.CSVCMsgGameEventList_keyT.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCSVCMsgGameEventList_descriptorT();
        message.eventid = (_a = object.eventid) !== null && _a !== void 0 ? _a : 0;
        message.name = (_b = object.name) !== null && _b !== void 0 ? _b : "";
        message.keys =
            ((_c = object.keys) === null || _c === void 0 ? void 0 : _c.map(e => exports.CSVCMsgGameEventList_keyT.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCSVCMsgTempEntities() {
    return { reliable: false, numEntries: 0, entityData: new Uint8Array() };
}
exports.CSVCMsgTempEntities = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.reliable === true) {
            writer.uint32(8).bool(message.reliable);
        }
        if (message.numEntries !== 0) {
            writer.uint32(16).int32(message.numEntries);
        }
        if (message.entityData.length !== 0) {
            writer.uint32(26).bytes(message.entityData);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgTempEntities();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.reliable = reader.bool();
                    break;
                case 2:
                    message.numEntries = reader.int32();
                    break;
                case 3:
                    message.entityData = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCSVCMsgTempEntities();
        message.reliable = (_a = object.reliable) !== null && _a !== void 0 ? _a : false;
        message.numEntries = (_b = object.numEntries) !== null && _b !== void 0 ? _b : 0;
        message.entityData = (_c = object.entityData) !== null && _c !== void 0 ? _c : new Uint8Array();
        return message;
    }
};
function createBaseCSVCMsgPacketEntities() {
    return {
        maxEntries: 0,
        updatedEntries: 0,
        isDelta: false,
        updateBaseline: false,
        baseline: 0,
        deltaFrom: 0,
        entityData: new Uint8Array()
    };
}
exports.CSVCMsgPacketEntities = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.maxEntries !== 0) {
            writer.uint32(8).int32(message.maxEntries);
        }
        if (message.updatedEntries !== 0) {
            writer.uint32(16).int32(message.updatedEntries);
        }
        if (message.isDelta === true) {
            writer.uint32(24).bool(message.isDelta);
        }
        if (message.updateBaseline === true) {
            writer.uint32(32).bool(message.updateBaseline);
        }
        if (message.baseline !== 0) {
            writer.uint32(40).int32(message.baseline);
        }
        if (message.deltaFrom !== 0) {
            writer.uint32(48).int32(message.deltaFrom);
        }
        if (message.entityData.length !== 0) {
            writer.uint32(58).bytes(message.entityData);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgPacketEntities();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.maxEntries = reader.int32();
                    break;
                case 2:
                    message.updatedEntries = reader.int32();
                    break;
                case 3:
                    message.isDelta = reader.bool();
                    break;
                case 4:
                    message.updateBaseline = reader.bool();
                    break;
                case 5:
                    message.baseline = reader.int32();
                    break;
                case 6:
                    message.deltaFrom = reader.int32();
                    break;
                case 7:
                    message.entityData = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g;
        const message = createBaseCSVCMsgPacketEntities();
        message.maxEntries = (_a = object.maxEntries) !== null && _a !== void 0 ? _a : 0;
        message.updatedEntries = (_b = object.updatedEntries) !== null && _b !== void 0 ? _b : 0;
        message.isDelta = (_c = object.isDelta) !== null && _c !== void 0 ? _c : false;
        message.updateBaseline = (_d = object.updateBaseline) !== null && _d !== void 0 ? _d : false;
        message.baseline = (_e = object.baseline) !== null && _e !== void 0 ? _e : 0;
        message.deltaFrom = (_f = object.deltaFrom) !== null && _f !== void 0 ? _f : 0;
        message.entityData = (_g = object.entityData) !== null && _g !== void 0 ? _g : new Uint8Array();
        return message;
    }
};
function createBaseCSVCMsgSounds() {
    return { reliableSound: false, sounds: [] };
}
exports.CSVCMsgSounds = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.reliableSound === true) {
            writer.uint32(8).bool(message.reliableSound);
        }
        for (const v of message.sounds) {
            exports.CSVCMsgSounds_sounddataT.encode(v, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgSounds();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.reliableSound = reader.bool();
                    break;
                case 2:
                    message.sounds.push(exports.CSVCMsgSounds_sounddataT.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCSVCMsgSounds();
        message.reliableSound = (_a = object.reliableSound) !== null && _a !== void 0 ? _a : false;
        message.sounds =
            ((_b = object.sounds) === null || _b === void 0 ? void 0 : _b.map(e => exports.CSVCMsgSounds_sounddataT.fromPartial(e))) || [];
        return message;
    }
};
function createBaseCSVCMsgSounds_sounddataT() {
    return {
        originX: 0,
        originY: 0,
        originZ: 0,
        volume: 0,
        delayValue: 0,
        sequenceNumber: 0,
        entityIndex: 0,
        channel: 0,
        pitch: 0,
        flags: 0,
        soundNum: 0,
        soundNumHandle: 0,
        speakerEntity: 0,
        randomSeed: 0,
        soundLevel: 0,
        isSentence: false,
        isAmbient: false
    };
}
exports.CSVCMsgSounds_sounddataT = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.originX !== 0) {
            writer.uint32(8).sint32(message.originX);
        }
        if (message.originY !== 0) {
            writer.uint32(16).sint32(message.originY);
        }
        if (message.originZ !== 0) {
            writer.uint32(24).sint32(message.originZ);
        }
        if (message.volume !== 0) {
            writer.uint32(32).uint32(message.volume);
        }
        if (message.delayValue !== 0) {
            writer.uint32(45).float(message.delayValue);
        }
        if (message.sequenceNumber !== 0) {
            writer.uint32(48).int32(message.sequenceNumber);
        }
        if (message.entityIndex !== 0) {
            writer.uint32(56).int32(message.entityIndex);
        }
        if (message.channel !== 0) {
            writer.uint32(64).int32(message.channel);
        }
        if (message.pitch !== 0) {
            writer.uint32(72).int32(message.pitch);
        }
        if (message.flags !== 0) {
            writer.uint32(80).int32(message.flags);
        }
        if (message.soundNum !== 0) {
            writer.uint32(88).uint32(message.soundNum);
        }
        if (message.soundNumHandle !== 0) {
            writer.uint32(101).fixed32(message.soundNumHandle);
        }
        if (message.speakerEntity !== 0) {
            writer.uint32(104).int32(message.speakerEntity);
        }
        if (message.randomSeed !== 0) {
            writer.uint32(112).int32(message.randomSeed);
        }
        if (message.soundLevel !== 0) {
            writer.uint32(120).int32(message.soundLevel);
        }
        if (message.isSentence === true) {
            writer.uint32(128).bool(message.isSentence);
        }
        if (message.isAmbient === true) {
            writer.uint32(136).bool(message.isAmbient);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgSounds_sounddataT();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.originX = reader.sint32();
                    break;
                case 2:
                    message.originY = reader.sint32();
                    break;
                case 3:
                    message.originZ = reader.sint32();
                    break;
                case 4:
                    message.volume = reader.uint32();
                    break;
                case 5:
                    message.delayValue = reader.float();
                    break;
                case 6:
                    message.sequenceNumber = reader.int32();
                    break;
                case 7:
                    message.entityIndex = reader.int32();
                    break;
                case 8:
                    message.channel = reader.int32();
                    break;
                case 9:
                    message.pitch = reader.int32();
                    break;
                case 10:
                    message.flags = reader.int32();
                    break;
                case 11:
                    message.soundNum = reader.uint32();
                    break;
                case 12:
                    message.soundNumHandle = reader.fixed32();
                    break;
                case 13:
                    message.speakerEntity = reader.int32();
                    break;
                case 14:
                    message.randomSeed = reader.int32();
                    break;
                case 15:
                    message.soundLevel = reader.int32();
                    break;
                case 16:
                    message.isSentence = reader.bool();
                    break;
                case 17:
                    message.isAmbient = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
        const message = createBaseCSVCMsgSounds_sounddataT();
        message.originX = (_a = object.originX) !== null && _a !== void 0 ? _a : 0;
        message.originY = (_b = object.originY) !== null && _b !== void 0 ? _b : 0;
        message.originZ = (_c = object.originZ) !== null && _c !== void 0 ? _c : 0;
        message.volume = (_d = object.volume) !== null && _d !== void 0 ? _d : 0;
        message.delayValue = (_e = object.delayValue) !== null && _e !== void 0 ? _e : 0;
        message.sequenceNumber = (_f = object.sequenceNumber) !== null && _f !== void 0 ? _f : 0;
        message.entityIndex = (_g = object.entityIndex) !== null && _g !== void 0 ? _g : 0;
        message.channel = (_h = object.channel) !== null && _h !== void 0 ? _h : 0;
        message.pitch = (_j = object.pitch) !== null && _j !== void 0 ? _j : 0;
        message.flags = (_k = object.flags) !== null && _k !== void 0 ? _k : 0;
        message.soundNum = (_l = object.soundNum) !== null && _l !== void 0 ? _l : 0;
        message.soundNumHandle = (_m = object.soundNumHandle) !== null && _m !== void 0 ? _m : 0;
        message.speakerEntity = (_o = object.speakerEntity) !== null && _o !== void 0 ? _o : 0;
        message.randomSeed = (_p = object.randomSeed) !== null && _p !== void 0 ? _p : 0;
        message.soundLevel = (_q = object.soundLevel) !== null && _q !== void 0 ? _q : 0;
        message.isSentence = (_r = object.isSentence) !== null && _r !== void 0 ? _r : false;
        message.isAmbient = (_s = object.isAmbient) !== null && _s !== void 0 ? _s : false;
        return message;
    }
};
function createBaseCSVCMsgEntityMsg() {
    return { entIndex: 0, classId: 0, entData: new Uint8Array() };
}
exports.CSVCMsgEntityMsg = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.entIndex !== 0) {
            writer.uint32(8).int32(message.entIndex);
        }
        if (message.classId !== 0) {
            writer.uint32(16).int32(message.classId);
        }
        if (message.entData.length !== 0) {
            writer.uint32(26).bytes(message.entData);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgEntityMsg();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.entIndex = reader.int32();
                    break;
                case 2:
                    message.classId = reader.int32();
                    break;
                case 3:
                    message.entData = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c;
        const message = createBaseCSVCMsgEntityMsg();
        message.entIndex = (_a = object.entIndex) !== null && _a !== void 0 ? _a : 0;
        message.classId = (_b = object.classId) !== null && _b !== void 0 ? _b : 0;
        message.entData = (_c = object.entData) !== null && _c !== void 0 ? _c : new Uint8Array();
        return message;
    }
};
function createBaseCSVCMsgCmdKeyValues() {
    return { keyvalues: new Uint8Array() };
}
exports.CSVCMsgCmdKeyValues = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.keyvalues.length !== 0) {
            writer.uint32(10).bytes(message.keyvalues);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgCmdKeyValues();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.keyvalues = reader.bytes();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCSVCMsgCmdKeyValues();
        message.keyvalues = (_a = object.keyvalues) !== null && _a !== void 0 ? _a : new Uint8Array();
        return message;
    }
};
function createBaseCSVCMsgEncryptedData() {
    return { encrypted: new Uint8Array(), keyType: 0 };
}
exports.CSVCMsgEncryptedData = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.encrypted.length !== 0) {
            writer.uint32(10).bytes(message.encrypted);
        }
        if (message.keyType !== 0) {
            writer.uint32(16).int32(message.keyType);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgEncryptedData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.encrypted = reader.bytes();
                    break;
                case 2:
                    message.keyType = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCSVCMsgEncryptedData();
        message.encrypted = (_a = object.encrypted) !== null && _a !== void 0 ? _a : new Uint8Array();
        message.keyType = (_b = object.keyType) !== null && _b !== void 0 ? _b : 0;
        return message;
    }
};
function createBaseCSVCMsgHltvReplay() {
    return {
        delay: 0,
        primaryTarget: 0,
        replayStopAt: 0,
        replayStartAt: 0,
        replaySlowdownBegin: 0,
        replaySlowdownEnd: 0,
        replaySlowdownRate: 0
    };
}
exports.CSVCMsgHltvReplay = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.delay !== 0) {
            writer.uint32(8).int32(message.delay);
        }
        if (message.primaryTarget !== 0) {
            writer.uint32(16).int32(message.primaryTarget);
        }
        if (message.replayStopAt !== 0) {
            writer.uint32(24).int32(message.replayStopAt);
        }
        if (message.replayStartAt !== 0) {
            writer.uint32(32).int32(message.replayStartAt);
        }
        if (message.replaySlowdownBegin !== 0) {
            writer.uint32(40).int32(message.replaySlowdownBegin);
        }
        if (message.replaySlowdownEnd !== 0) {
            writer.uint32(48).int32(message.replaySlowdownEnd);
        }
        if (message.replaySlowdownRate !== 0) {
            writer.uint32(61).float(message.replaySlowdownRate);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgHltvReplay();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.delay = reader.int32();
                    break;
                case 2:
                    message.primaryTarget = reader.int32();
                    break;
                case 3:
                    message.replayStopAt = reader.int32();
                    break;
                case 4:
                    message.replayStartAt = reader.int32();
                    break;
                case 5:
                    message.replaySlowdownBegin = reader.int32();
                    break;
                case 6:
                    message.replaySlowdownEnd = reader.int32();
                    break;
                case 7:
                    message.replaySlowdownRate = reader.float();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e, _f, _g;
        const message = createBaseCSVCMsgHltvReplay();
        message.delay = (_a = object.delay) !== null && _a !== void 0 ? _a : 0;
        message.primaryTarget = (_b = object.primaryTarget) !== null && _b !== void 0 ? _b : 0;
        message.replayStopAt = (_c = object.replayStopAt) !== null && _c !== void 0 ? _c : 0;
        message.replayStartAt = (_d = object.replayStartAt) !== null && _d !== void 0 ? _d : 0;
        message.replaySlowdownBegin = (_e = object.replaySlowdownBegin) !== null && _e !== void 0 ? _e : 0;
        message.replaySlowdownEnd = (_f = object.replaySlowdownEnd) !== null && _f !== void 0 ? _f : 0;
        message.replaySlowdownRate = (_g = object.replaySlowdownRate) !== null && _g !== void 0 ? _g : 0;
        return message;
    }
};
function createBaseCCLCMsgHltvReplay() {
    return {
        request: 0,
        slowdownLength: 0,
        slowdownRate: 0,
        primaryTargetEntIndex: 0,
        eventTime: 0
    };
}
exports.CCLCMsgHltvReplay = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.request !== 0) {
            writer.uint32(8).int32(message.request);
        }
        if (message.slowdownLength !== 0) {
            writer.uint32(21).float(message.slowdownLength);
        }
        if (message.slowdownRate !== 0) {
            writer.uint32(29).float(message.slowdownRate);
        }
        if (message.primaryTargetEntIndex !== 0) {
            writer.uint32(32).int32(message.primaryTargetEntIndex);
        }
        if (message.eventTime !== 0) {
            writer.uint32(45).float(message.eventTime);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCCLCMsgHltvReplay();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.request = reader.int32();
                    break;
                case 2:
                    message.slowdownLength = reader.float();
                    break;
                case 3:
                    message.slowdownRate = reader.float();
                    break;
                case 4:
                    message.primaryTargetEntIndex = reader.int32();
                    break;
                case 5:
                    message.eventTime = reader.float();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a, _b, _c, _d, _e;
        const message = createBaseCCLCMsgHltvReplay();
        message.request = (_a = object.request) !== null && _a !== void 0 ? _a : 0;
        message.slowdownLength = (_b = object.slowdownLength) !== null && _b !== void 0 ? _b : 0;
        message.slowdownRate = (_c = object.slowdownRate) !== null && _c !== void 0 ? _c : 0;
        message.primaryTargetEntIndex = (_d = object.primaryTargetEntIndex) !== null && _d !== void 0 ? _d : 0;
        message.eventTime = (_e = object.eventTime) !== null && _e !== void 0 ? _e : 0;
        return message;
    }
};
function createBaseCSVCMsgBroadcastCommand() {
    return { cmd: "" };
}
exports.CSVCMsgBroadcastCommand = {
    encode(message, writer = minimal_1.Writer.create()) {
        if (message.cmd !== "") {
            writer.uint32(10).string(message.cmd);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCSVCMsgBroadcastCommand();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.cmd = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCSVCMsgBroadcastCommand();
        message.cmd = (_a = object.cmd) !== null && _a !== void 0 ? _a : "";
        return message;
    }
};
// If you get a compile-error about 'Constructor<Long> and ... have no overlap',
// add '--ts_proto_opt=esModuleInterop=true' as a flag when calling 'protoc'.
if (minimal_1.util.Long !== Long) {
    minimal_1.util.Long = Long;
    (0, minimal_1.configure)();
}

},{"long":712,"protobufjs/minimal":715}],28:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.decodeShareCode = void 0;
const bigInt = require("big-integer");
const DICTIONARY = "ABCDEFGHJKLMNOPQRSTUVWXYZabcdefhijkmnopqrstuvwxyz23456789";
function decodeShareCode(shareCode) {
    if (!/^CSGO(-[\w]{5}){5}$/.exec(shareCode))
        throw new Error(`invalid share code: ${shareCode}`);
    const code = shareCode.substring(5).replace(/-/g, "");
    let big = bigInt.zero;
    for (let i = code.length - 1; i >= 0; --i) {
        big = big.multiply(DICTIONARY.length).plus(DICTIONARY.indexOf(code[i]));
    }
    const array = big.toArray(256).value;
    if (array.length === 18) {
        array.unshift(0);
    }
    return array;
}
exports.decodeShareCode = decodeShareCode;

},{"big-integer":78}],29:[function(require,module,exports){
(function (Buffer){(function (){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.StringTables = void 0;
const assert = require("assert");
const ByteBuffer = require("bytebuffer");
const events_1 = require("events");
const Long = require("long");
const assert_exists_1 = require("./assert-exists");
const consts = require("./consts");
const consts_1 = require("./consts");
const bitbuffer_1 = require("./ext/bitbuffer");
function parseUserInfoData(buf) {
    const bytebuf = ByteBuffer.wrap(buf, ByteBuffer.BIG_ENDIAN);
    bytebuf.skip(8);
    const hi = bytebuf.readUint32();
    const lo = bytebuf.readUint32();
    const xuid = Long.fromBits(lo, hi);
    const name = bytebuf
        .readString(consts_1.MAX_PLAYER_NAME_LENGTH, ByteBuffer.METRICS_BYTES)
        .split("\0", 2)[0];
    const userId = bytebuf.readUint32();
    const guid = bytebuf
        .readString(consts_1.SIGNED_GUID_LEN + 1, ByteBuffer.METRICS_BYTES)
        .split("\0", 2)[0];
    bytebuf.skip(3);
    const friendsId = bytebuf.readUint32();
    const friendsName = bytebuf
        .readString(consts_1.MAX_PLAYER_NAME_LENGTH, ByteBuffer.METRICS_BYTES)
        .split("\0", 2)[0];
    const fakePlayer = bytebuf.readByte() !== 0;
    bytebuf.skip(3);
    const isHltv = bytebuf.readByte() !== 0;
    bytebuf.skip(3);
    return {
        xuid,
        name,
        userId,
        guid,
        friendsId,
        friendsName,
        fakePlayer,
        isHltv
    };
}
/**
 * Handles string tables for a demo file.
 */
class StringTables extends events_1.EventEmitter {
    constructor() {
        super();
        this.tables = [];
        /**
         * User data handlers. Transform raw buffer into any other value.
         * By default, `userinfo` user data is transformed to {@link PlayerInfo}
         * objects.
         */
        this.userDataCallbacks = {
            userinfo: parseUserInfoData
        };
    }
    listen(messageEvents) {
        messageEvents.on("svc_UpdateStringTable", this._handleUpdateStringTable.bind(this));
        messageEvents.on("svc_CreateStringTable", this._handleCreateStringTable.bind(this));
    }
    findTableByName(name) {
        return this.tables.find(table => table.name === name);
    }
    handleStringTables(bitbuf) {
        const numTables = bitbuf.readUInt8();
        for (let i = 0; i < numTables; ++i) {
            const tableName = bitbuf.readCString();
            this._handleStringTable(tableName, bitbuf);
        }
    }
    _handleStringTable(name, bitbuf) {
        var _a;
        const userDataCallback = this.userDataCallbacks[name];
        const table = (0, assert_exists_1.default)(this.findTableByName(name));
        const numEntries = bitbuf.readUInt16();
        for (let entryIndex = 0; entryIndex < numEntries; ++entryIndex) {
            const entry = bitbuf.readCString();
            let userData = null;
            // has user data?
            if (bitbuf.readOneBit()) {
                const userDataSize = bitbuf.readUInt16();
                const userDataBuf = bitbuf.readBytes(userDataSize);
                userData =
                    userDataCallback === undefined
                        ? userDataBuf
                        : userDataCallback(userDataBuf);
            }
            const oldUserData = (_a = table.entries[entryIndex]) === null || _a === void 0 ? void 0 : _a.userData;
            table.entries[entryIndex] = { entry, userData };
            this.emit("update", {
                table,
                entryIndex,
                entry,
                userData,
                oldUserData
            });
        }
        // parse client-side entries
        if (bitbuf.readOneBit()) {
            const numStrings = bitbuf.readUInt16();
            for (let i = 0; i < numStrings; ++i) {
                // eslint-disable-next-line @typescript-eslint/no-unused-vars
                const entry = bitbuf.readCString();
                let userData = null;
                if (bitbuf.readOneBit()) {
                    const userDataSize = bitbuf.readUInt16();
                    const userDataBuf = bitbuf.readBytes(userDataSize);
                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
                    userData =
                        userDataCallback === undefined
                            ? userDataBuf
                            : userDataCallback(userDataBuf);
                }
                // TODO: do something with client-side entries
            }
        }
        // table is ready
        this.emit("postcreate", table);
    }
    _parseStringTableUpdate(bitbuf, table, entries) {
        const history = [];
        const entryBits = Math.ceil(Math.log2(table.maxEntries));
        const userDataCallback = this.userDataCallbacks[table.name];
        assert(!bitbuf.readOneBit(), "dictionary encoding unsupported");
        let entryIndex = -1;
        for (let i = 0; i < entries; ++i) {
            entryIndex += 1;
            if (!bitbuf.readOneBit()) {
                entryIndex = bitbuf.readUBits(entryBits);
            }
            assert(entryIndex >= 0 && entryIndex < table.maxEntries, "bogus string index");
            const existingEntry = table.entries[entryIndex];
            let entry = null;
            // has the entry changed?
            if (bitbuf.readOneBit()) {
                // substring check
                if (bitbuf.readOneBit()) {
                    const index = bitbuf.readUBits(5);
                    const bytesToCopy = bitbuf.readUBits(consts.SUBSTRING_BITS);
                    const last = history[index];
                    if (last == null) {
                        throw new Error("string table entry is delta from non existent entry");
                    }
                    const subStr = last.slice(0, bytesToCopy);
                    const suffix = bitbuf.readCString();
                    entry = subStr + suffix;
                }
                else {
                    entry = bitbuf.readCString();
                }
            }
            else {
                // If the string itself hasn't changed, this entry must already exist
                entry = (0, assert_exists_1.default)(existingEntry).entry;
            }
            // read in the user data
            let userData = null;
            if (bitbuf.readOneBit()) {
                // don't read the length, it's fixed length and the length was networked down already
                if (table.userDataFixedSize) {
                    const userDataArray = [bitbuf.readUBits(table.userDataSizeBits)];
                    userData = Buffer.from(userDataArray);
                }
                else {
                    const bytes = bitbuf.readUBits(consts.MAX_USERDATA_BITS);
                    userData = bitbuf.readBytes(bytes);
                }
                if (userDataCallback !== undefined) {
                    userData = userDataCallback(userData);
                }
            }
            else {
                userData = existingEntry === null || existingEntry === void 0 ? void 0 : existingEntry.userData;
            }
            const oldUserData = existingEntry === null || existingEntry === void 0 ? void 0 : existingEntry.userData;
            table.entries[entryIndex] = { entry, userData };
            // add to history
            if (history.length > 31) {
                history.shift();
            }
            history.push(entry);
            this.emit("update", {
                table,
                entryIndex,
                entry,
                userData,
                oldUserData
            });
        }
    }
    _handleCreateStringTable(msg) {
        const bitbuf = bitbuffer_1.BitStream.from(msg.stringData);
        // table shouldn't already exist
        assert(this.findTableByName(msg.name) === undefined, "table already exists");
        assert(msg.userDataSize === Math.ceil(msg.userDataSizeBits / 8), "invalid user data byte size");
        assert(msg.userDataSizeBits <= 32, "userdata value too large");
        // create an empty table
        const table = {
            name: msg.name,
            entries: [],
            userDataSizeBits: msg.userDataSizeBits,
            userDataFixedSize: msg.userDataFixedSize,
            maxEntries: msg.maxEntries
        };
        this.emit("create", table);
        this._parseStringTableUpdate(bitbuf, table, msg.numEntries);
        this.tables.push(table);
    }
    _handleUpdateStringTable(msg) {
        const bitbuf = bitbuffer_1.BitStream.from(msg.stringData);
        const table = (0, assert_exists_1.default)(this.tables[msg.tableId], "bad table index");
        this._parseStringTableUpdate(bitbuf, table, msg.numChangedEntries);
    }
}
exports.StringTables = StringTables;

}).call(this)}).call(this,require("buffer").Buffer)

},{"./assert-exists":2,"./consts":3,"./ext/bitbuffer":18,"assert":73,"buffer":81,"bytebuffer":83,"events":84,"long":712}],30:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const assert = require("assert");
const projectile_1 = require("../entities/projectile");
const supplement = {
    emits: ["grenadeTrajectory"],
    setup: function grenadeTrajectory(demo) {
        const trajectories = new Map();
        function onEntityCreate(event) {
            // We only care about grenade projectiles
            if (!(event.entity instanceof projectile_1.Projectile))
                return;
            assert(!trajectories.has(event.entity.index));
            trajectories.set(event.entity.index, [event.entity.position]);
        }
        function onEntityRemove(event) {
            // If a projectile was thrown just before round end,
            // it would be deleted before detonating.
            trajectories.delete(event.index);
        }
        function onEntityChange(event) {
            const index = event.entity.index;
            if (!trajectories.has(index))
                return;
            const projectile = event.entity;
            for (const change of event.changes) {
                if (change.varName !== "m_nBounces")
                    continue;
                const oldValue = (change.oldValue || 0);
                const newValue = change.newValue;
                if (newValue > oldValue) {
                    trajectories.get(index).push(projectile.position);
                }
            }
        }
        function onGrenadeDetonateEvent(event) {
            const projectile = event.entity;
            // todo: when could this be null?
            const trajectory = trajectories.get(event.entityid);
            trajectory.push(projectile.position);
            demo.emit("grenadeTrajectory", {
                projectile,
                thrower: event.player,
                trajectory
            });
        }
        function onMolotovDetonate({ projectile, thrower }) {
            // todo: when could this be null?
            const trajectory = trajectories.get(projectile.index);
            trajectory.push(projectile.position);
            demo.emit("grenadeTrajectory", {
                projectile,
                thrower,
                trajectory
            });
        }
        demo.on("molotovDetonate", onMolotovDetonate);
        demo.entities.on("create", onEntityCreate);
        demo.entities.on("change", onEntityChange);
        demo.entities.on("remove", onEntityRemove);
        demo.gameEvents.on("decoy_detonate", onGrenadeDetonateEvent);
        demo.gameEvents.on("flashbang_detonate", onGrenadeDetonateEvent);
        demo.gameEvents.on("hegrenade_detonate", onGrenadeDetonateEvent);
        demo.gameEvents.on("smokegrenade_detonate", onGrenadeDetonateEvent);
        return () => {
            demo.off("molotovDetonate", onMolotovDetonate);
            demo.entities.off("create", onEntityCreate);
            demo.entities.off("change", onEntityChange);
            demo.entities.off("remove", onEntityRemove);
            demo.gameEvents.off("decoy_detonate", onGrenadeDetonateEvent);
            demo.gameEvents.off("flashbang_detonate", onGrenadeDetonateEvent);
            demo.gameEvents.off("hegrenade_detonate", onGrenadeDetonateEvent);
            demo.gameEvents.off("smokegrenade_detonate", onGrenadeDetonateEvent);
        };
    }
};
exports.default = supplement;

},{"../entities/projectile":13,"assert":73}],31:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const player_1 = require("../entities/player");
const itemdefs_1 = require("../entities/itemdefs");
const equipmentIdMap = {
    "50": "Kevlar",
    "51": "Assault Suit",
    "55": "Defuser"
};
const supplement = {
    emits: ["itemPurchase"],
    setup: function purchase(demo) {
        let pendingPurchases = [];
        // Wait until tick end to find the entity.
        // m_iWeaponPurchasesThisRound is always updated before the weapon entity is created.
        function onTickEnd() {
            for (const pending of pendingPurchases) {
                // Some items won't have an entity representation, e.g. kevlar.
                let weapon = pending.player.weapons.find(w => w.itemIndex === pending.weaponId);
                // todo: why does molotov need remapping to incendiary?
                if (!weapon && pending.weaponId === 46) {
                    weapon = pending.player.weapons.find(w => w.itemIndex === 48);
                }
                demo.emit("itemPurchase", { ...pending, weapon });
            }
            pendingPurchases = [];
        }
        function onEntityChange(e) {
            var _a;
            if (!(e.entity instanceof player_1.Player))
                return;
            // PERF: add ability to listen on specific tables
            for (const change of e.changes) {
                if (change.tableName !== "m_iWeaponPurchasesThisRound")
                    continue;
                const weaponId = parseInt(change.varName, 10);
                const oldValue = (change.oldValue || 0);
                const newValue = change.newValue;
                const count = newValue - oldValue;
                if (count > 0) {
                    pendingPurchases.push({
                        player: e.entity,
                        weaponId,
                        itemName: ((_a = itemdefs_1.itemDefinitionIndexMap[weaponId]) === null || _a === void 0 ? void 0 : _a.itemName) ||
                            equipmentIdMap[weaponId] ||
                            "Unknown",
                        count,
                        weapon: undefined
                    });
                }
            }
        }
        demo.on("tickend", onTickEnd);
        demo.entities.on("change", onEntityChange);
        return () => {
            demo.off("tickend", onTickEnd);
            demo.entities.off("change", onEntityChange);
        };
    }
};
exports.default = supplement;

},{"../entities/itemdefs":10,"../entities/player":12}],32:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const consts_1 = require("../consts");
const molotovLoop = 1051353634; // murmurhash.v2("molotov.loop", 1146049601)
const supplement = {
    emits: ["molotovDetonate"],
    setup: function molotovDetonate(demo) {
        if (demo.currentTick >= 0) {
            throw new Error("molotovDetonate event listeners must be added before parsing starts.");
        }
        // Find the index of the fire loop sound.
        // This is emitted when the grenade is thrown, and then stopped when it detonates.
        let fireLoopSoundIndex = -1;
        function onStringTableUpdate(e) {
            if (e.table.name === "soundprecache") {
                if (e.entry === "weapons/molotov/fire_loop_1.wav") {
                    fireLoopSoundIndex = e.entryIndex;
                }
            }
        }
        // Cache the molotov projectile class.
        // Note that this entity is shared between molotov and incendiary grenades.
        let molotovProjectileClass = -1;
        function onDataTablesReady() {
            molotovProjectileClass = demo.entities.serverClasses.findIndex(sc => sc.name === "CMolotovProjectile");
        }
        function onSound(e) {
            if (fireLoopSoundIndex < 0 || molotovProjectileClass < 0)
                return;
            for (const sound of e.sounds) {
                // We only care about the fire loop sound
                if (sound.soundNumHandle === 0) {
                    if (sound.soundNum !== fireLoopSoundIndex)
                        continue;
                }
                else {
                    // todo: never actually see this
                    if (sound.soundNumHandle !== molotovLoop)
                        continue;
                }
                // The loop sound starts when the grenade is thrown,
                // and is stopped on detonation.
                if ((sound.flags & consts_1.SND_STOP) === 0)
                    continue;
                const projectile = demo.entities.entities.get(sound.entityIndex);
                if (!projectile)
                    continue;
                // This sound is also stopped on the resulting inferno
                // (i.e. the flames produced by a detonated fire grenade).
                if (projectile.classId === molotovProjectileClass) {
                    const thrower = projectile.owner;
                    demo.emit("molotovDetonate", {
                        thrower,
                        projectile
                    });
                }
            }
        }
        demo.stringTables.on("update", onStringTableUpdate);
        demo.entities.on("datatablesready", onDataTablesReady);
        demo.on("svc_Sounds", onSound);
        return () => {
            demo.stringTables.off("update", onStringTableUpdate);
            demo.entities.off("datatablesready", onDataTablesReady);
            demo.off("svc_Sounds", onSound);
        };
    }
};
exports.default = supplement;

},{"../consts":3}],33:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.UserMessages = void 0;
const assert = require("assert");
const events_1 = require("events");
const usermessagetypes_1 = require("./usermessagetypes");
/**
 * Handles user messages for a demo file.
 */
class UserMessages extends events_1.EventEmitter {
    listen(demo) {
        demo.on("svc_UserMessage", this._handleUserMessage.bind(this));
    }
    _handleUserMessage(msg) {
        const um = usermessagetypes_1.userMessages[msg.msgType];
        if (!um) {
            return;
        }
        if (this.listenerCount(um.name) || this.listenerCount("message")) {
            const msgInst = um.class.decode(msg.msgData);
            assert(msgInst, "unable to decode user message");
            this.emit(um.name, msgInst);
            this.emit("message", {
                name: um.name,
                msg: msgInst
            });
        }
    }
}
exports.UserMessages = UserMessages;

},{"./usermessagetypes":34,"assert":73,"events":84}],34:[function(require,module,exports){
"use strict";
// DO NOT MODIFY!
// Auto-generated by ./generators/usermessagetypes.ts
Object.defineProperty(exports, "__esModule", { value: true });
exports.userMessages = void 0;
const um = require("./protobufs/cstrike15_usermessages");
exports.userMessages = [];
exports.userMessages[um.ECstrike15UserMessages.CS_UM_VGUIMenu] = {
    name: "VGUIMenu",
    class: um.CCSUsrMsgVGUIMenu
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_Geiger] = {
    name: "Geiger",
    class: um.CCSUsrMsgGeiger
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_Train] = {
    name: "Train",
    class: um.CCSUsrMsgTrain
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_HudText] = {
    name: "HudText",
    class: um.CCSUsrMsgHudText
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_SayText] = {
    name: "SayText",
    class: um.CCSUsrMsgSayText
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_SayText2] = {
    name: "SayText2",
    class: um.CCSUsrMsgSayText2
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_TextMsg] = {
    name: "TextMsg",
    class: um.CCSUsrMsgTextMsg
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_HudMsg] = {
    name: "HudMsg",
    class: um.CCSUsrMsgHudMsg
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_ResetHud] = {
    name: "ResetHud",
    class: um.CCSUsrMsgResetHud
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_GameTitle] = {
    name: "GameTitle",
    class: um.CCSUsrMsgGameTitle
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_Shake] = {
    name: "Shake",
    class: um.CCSUsrMsgShake
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_Fade] = {
    name: "Fade",
    class: um.CCSUsrMsgFade
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_Rumble] = {
    name: "Rumble",
    class: um.CCSUsrMsgRumble
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_CloseCaption] = {
    name: "CloseCaption",
    class: um.CCSUsrMsgCloseCaption
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_CloseCaptionDirect] = {
    name: "CloseCaptionDirect",
    class: um.CCSUsrMsgCloseCaptionDirect
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_SendAudio] = {
    name: "SendAudio",
    class: um.CCSUsrMsgSendAudio
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_RawAudio] = {
    name: "RawAudio",
    class: um.CCSUsrMsgRawAudio
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_VoiceMask] = {
    name: "VoiceMask",
    class: um.CCSUsrMsgVoiceMask
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_RequestState] = {
    name: "RequestState",
    class: um.CCSUsrMsgRequestState
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_Damage] = {
    name: "Damage",
    class: um.CCSUsrMsgDamage
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_RadioText] = {
    name: "RadioText",
    class: um.CCSUsrMsgRadioText
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_HintText] = {
    name: "HintText",
    class: um.CCSUsrMsgHintText
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_KeyHintText] = {
    name: "KeyHintText",
    class: um.CCSUsrMsgKeyHintText
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_ProcessSpottedEntityUpdate] = {
    name: "ProcessSpottedEntityUpdate",
    class: um.CCSUsrMsgProcessSpottedEntityUpdate
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_ReloadEffect] = {
    name: "ReloadEffect",
    class: um.CCSUsrMsgReloadEffect
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_AdjustMoney] = {
    name: "AdjustMoney",
    class: um.CCSUsrMsgAdjustMoney
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_StopSpectatorMode] = {
    name: "StopSpectatorMode",
    class: um.CCSUsrMsgStopSpectatorMode
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_KillCam] = {
    name: "KillCam",
    class: um.CCSUsrMsgKillCam
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_DesiredTimescale] = {
    name: "DesiredTimescale",
    class: um.CCSUsrMsgDesiredTimescale
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_CurrentTimescale] = {
    name: "CurrentTimescale",
    class: um.CCSUsrMsgCurrentTimescale
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_AchievementEvent] = {
    name: "AchievementEvent",
    class: um.CCSUsrMsgAchievementEvent
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_MatchEndConditions] = {
    name: "MatchEndConditions",
    class: um.CCSUsrMsgMatchEndConditions
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_DisconnectToLobby] = {
    name: "DisconnectToLobby",
    class: um.CCSUsrMsgDisconnectToLobby
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_PlayerStatsUpdate] = {
    name: "PlayerStatsUpdate",
    class: um.CCSUsrMsgPlayerStatsUpdate
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_DisplayInventory] = {
    name: "DisplayInventory",
    class: um.CCSUsrMsgDisplayInventory
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_WarmupHasEnded] = {
    name: "WarmupHasEnded",
    class: um.CCSUsrMsgWarmupHasEnded
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_ClientInfo] = {
    name: "ClientInfo",
    class: um.CCSUsrMsgClientInfo
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_XRankGet] = {
    name: "XRankGet",
    class: um.CCSUsrMsgXRankGet
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_XRankUpd] = {
    name: "XRankUpd",
    class: um.CCSUsrMsgXRankUpd
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_CallVoteFailed] = {
    name: "CallVoteFailed",
    class: um.CCSUsrMsgCallVoteFailed
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_VoteStart] = {
    name: "VoteStart",
    class: um.CCSUsrMsgVoteStart
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_VotePass] = {
    name: "VotePass",
    class: um.CCSUsrMsgVotePass
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_VoteFailed] = {
    name: "VoteFailed",
    class: um.CCSUsrMsgVoteFailed
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_VoteSetup] = {
    name: "VoteSetup",
    class: um.CCSUsrMsgVoteSetup
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_ServerRankRevealAll] = {
    name: "ServerRankRevealAll",
    class: um.CCSUsrMsgServerRankRevealAll
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_SendLastKillerDamageToClient] = {
    name: "SendLastKillerDamageToClient",
    class: um.CCSUsrMsgSendLastKillerDamageToClient
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_ServerRankUpdate] = {
    name: "ServerRankUpdate",
    class: um.CCSUsrMsgServerRankUpdate
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_ItemPickup] = {
    name: "ItemPickup",
    class: um.CCSUsrMsgItemPickup
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_ShowMenu] = {
    name: "ShowMenu",
    class: um.CCSUsrMsgShowMenu
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_BarTime] = {
    name: "BarTime",
    class: um.CCSUsrMsgBarTime
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_AmmoDenied] = {
    name: "AmmoDenied",
    class: um.CCSUsrMsgAmmoDenied
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_MarkAchievement] = {
    name: "MarkAchievement",
    class: um.CCSUsrMsgMarkAchievement
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_MatchStatsUpdate] = {
    name: "MatchStatsUpdate",
    class: um.CCSUsrMsgMatchStatsUpdate
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_ItemDrop] = {
    name: "ItemDrop",
    class: um.CCSUsrMsgItemDrop
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_GlowPropTurnOff] = {
    name: "GlowPropTurnOff",
    class: um.CCSUsrMsgGlowPropTurnOff
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_SendPlayerItemDrops] = {
    name: "SendPlayerItemDrops",
    class: um.CCSUsrMsgSendPlayerItemDrops
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_RoundBackupFilenames] = {
    name: "RoundBackupFilenames",
    class: um.CCSUsrMsgRoundBackupFilenames
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_SendPlayerItemFound] = {
    name: "SendPlayerItemFound",
    class: um.CCSUsrMsgSendPlayerItemFound
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_ReportHit] = {
    name: "ReportHit",
    class: um.CCSUsrMsgReportHit
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_XpUpdate] = {
    name: "XpUpdate",
    class: um.CCSUsrMsgXpUpdate
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_QuestProgress] = {
    name: "QuestProgress",
    class: um.CCSUsrMsgQuestProgress
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_ScoreLeaderboardData] = {
    name: "ScoreLeaderboardData",
    class: um.CCSUsrMsgScoreLeaderboardData
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_PlayerDecalDigitalSignature] = {
    name: "PlayerDecalDigitalSignature",
    class: um.CCSUsrMsgPlayerDecalDigitalSignature
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_WeaponSound] = {
    name: "WeaponSound",
    class: um.CCSUsrMsgWeaponSound
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_UpdateScreenHealthBar] = {
    name: "UpdateScreenHealthBar",
    class: um.CCSUsrMsgUpdateScreenHealthBar
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_EntityOutlineHighlight] = {
    name: "EntityOutlineHighlight",
    class: um.CCSUsrMsgEntityOutlineHighlight
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_SSUI] = {
    name: "SSUI",
    class: um.CCSUsrMsgSSUI
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_SurvivalStats] = {
    name: "SurvivalStats",
    class: um.CCSUsrMsgSurvivalStats
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_EndOfMatchAllPlayersData] = {
    name: "EndOfMatchAllPlayersData",
    class: um.CCSUsrMsgEndOfMatchAllPlayersData
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_RoundImpactScoreData] = {
    name: "RoundImpactScoreData",
    class: um.CCSUsrMsgRoundImpactScoreData
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_CurrentRoundOdds] = {
    name: "CurrentRoundOdds",
    class: um.CCSUsrMsgCurrentRoundOdds
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_DeepStats] = {
    name: "DeepStats",
    class: um.CCSUsrMsgDeepStats
};
exports.userMessages[um.ECstrike15UserMessages.CS_UM_UtilMsg] = {
    name: "UtilMsg",
    class: um.CCSUsrMsgUtilMsg
};

},{"./protobufs/cstrike15_usermessages":25}],35:[function(require,module,exports){
var AwaitValue = require("./AwaitValue.js");

function AsyncGenerator(gen) {
  var front, back;

  function send(key, arg) {
    return new Promise(function (resolve, reject) {
      var request = {
        key: key,
        arg: arg,
        resolve: resolve,
        reject: reject,
        next: null
      };

      if (back) {
        back = back.next = request;
      } else {
        front = back = request;
        resume(key, arg);
      }
    });
  }

  function resume(key, arg) {
    try {
      var result = gen[key](arg);
      var value = result.value;
      var wrappedAwait = value instanceof AwaitValue;
      Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {
        if (wrappedAwait) {
          resume(key === "return" ? "return" : "next", arg);
          return;
        }

        settle(result.done ? "return" : "normal", arg);
      }, function (err) {
        resume("throw", err);
      });
    } catch (err) {
      settle("throw", err);
    }
  }

  function settle(type, value) {
    switch (type) {
      case "return":
        front.resolve({
          value: value,
          done: true
        });
        break;

      case "throw":
        front.reject(value);
        break;

      default:
        front.resolve({
          value: value,
          done: false
        });
        break;
    }

    front = front.next;

    if (front) {
      resume(front.key, front.arg);
    } else {
      back = null;
    }
  }

  this._invoke = send;

  if (typeof gen["return"] !== "function") {
    this["return"] = undefined;
  }
}

AsyncGenerator.prototype[typeof Symbol === "function" && Symbol.asyncIterator || "@@asyncIterator"] = function () {
  return this;
};

AsyncGenerator.prototype.next = function (arg) {
  return this._invoke("next", arg);
};

AsyncGenerator.prototype["throw"] = function (arg) {
  return this._invoke("throw", arg);
};

AsyncGenerator.prototype["return"] = function (arg) {
  return this._invoke("return", arg);
};

module.exports = AsyncGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{"./AwaitValue.js":36}],36:[function(require,module,exports){
function _AwaitValue(value) {
  this.wrapped = value;
}

module.exports = _AwaitValue, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],37:[function(require,module,exports){
function _arrayLikeToArray(arr, len) {
  if (len == null || len > arr.length) len = arr.length;

  for (var i = 0, arr2 = new Array(len); i < len; i++) {
    arr2[i] = arr[i];
  }

  return arr2;
}

module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],38:[function(require,module,exports){
function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}

module.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],39:[function(require,module,exports){
var arrayLikeToArray = require("./arrayLikeToArray.js");

function _arrayWithoutHoles(arr) {
  if (Array.isArray(arr)) return arrayLikeToArray(arr);
}

module.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{"./arrayLikeToArray.js":37}],40:[function(require,module,exports){
function _assertThisInitialized(self) {
  if (self === void 0) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return self;
}

module.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],41:[function(require,module,exports){
function _asyncGeneratorDelegate(inner, awaitWrap) {
  var iter = {},
      waiting = false;

  function pump(key, value) {
    waiting = true;
    value = new Promise(function (resolve) {
      resolve(inner[key](value));
    });
    return {
      done: false,
      value: awaitWrap(value)
    };
  }

  ;

  iter[typeof Symbol !== "undefined" && Symbol.iterator || "@@iterator"] = function () {
    return this;
  };

  iter.next = function (value) {
    if (waiting) {
      waiting = false;
      return value;
    }

    return pump("next", value);
  };

  if (typeof inner["throw"] === "function") {
    iter["throw"] = function (value) {
      if (waiting) {
        waiting = false;
        throw value;
      }

      return pump("throw", value);
    };
  }

  if (typeof inner["return"] === "function") {
    iter["return"] = function (value) {
      if (waiting) {
        waiting = false;
        return value;
      }

      return pump("return", value);
    };
  }

  return iter;
}

module.exports = _asyncGeneratorDelegate, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],42:[function(require,module,exports){
function _asyncIterator(iterable) {
  var method,
      async,
      sync,
      retry = 2;

  for ("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) {
    if (async && null != (method = iterable[async])) return method.call(iterable);
    if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));
    async = "@@asyncIterator", sync = "@@iterator";
  }

  throw new TypeError("Object is not async iterable");
}

function AsyncFromSyncIterator(s) {
  function AsyncFromSyncIteratorContinuation(r) {
    if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
    var done = r.done;
    return Promise.resolve(r.value).then(function (value) {
      return {
        value: value,
        done: done
      };
    });
  }

  return AsyncFromSyncIterator = function AsyncFromSyncIterator(s) {
    this.s = s, this.n = s.next;
  }, AsyncFromSyncIterator.prototype = {
    s: null,
    n: null,
    next: function next() {
      return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
    },
    "return": function _return(value) {
      var ret = this.s["return"];
      return void 0 === ret ? Promise.resolve({
        value: value,
        done: !0
      }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
    },
    "throw": function _throw(value) {
      var thr = this.s["return"];
      return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
    }
  }, new AsyncFromSyncIterator(s);
}

module.exports = _asyncIterator, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],43:[function(require,module,exports){
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
  try {
    var info = gen[key](arg);
    var value = info.value;
  } catch (error) {
    reject(error);
    return;
  }

  if (info.done) {
    resolve(value);
  } else {
    Promise.resolve(value).then(_next, _throw);
  }
}

function _asyncToGenerator(fn) {
  return function () {
    var self = this,
        args = arguments;
    return new Promise(function (resolve, reject) {
      var gen = fn.apply(self, args);

      function _next(value) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
      }

      function _throw(err) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
      }

      _next(undefined);
    });
  };
}

module.exports = _asyncToGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],44:[function(require,module,exports){
var AwaitValue = require("./AwaitValue.js");

function _awaitAsyncGenerator(value) {
  return new AwaitValue(value);
}

module.exports = _awaitAsyncGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{"./AwaitValue.js":36}],45:[function(require,module,exports){
function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],46:[function(require,module,exports){
var setPrototypeOf = require("./setPrototypeOf.js");

var isNativeReflectConstruct = require("./isNativeReflectConstruct.js");

function _construct(Parent, args, Class) {
  if (isNativeReflectConstruct()) {
    module.exports = _construct = Reflect.construct, module.exports.__esModule = true, module.exports["default"] = module.exports;
  } else {
    module.exports = _construct = function _construct(Parent, args, Class) {
      var a = [null];
      a.push.apply(a, args);
      var Constructor = Function.bind.apply(Parent, a);
      var instance = new Constructor();
      if (Class) setPrototypeOf(instance, Class.prototype);
      return instance;
    }, module.exports.__esModule = true, module.exports["default"] = module.exports;
  }

  return _construct.apply(null, arguments);
}

module.exports = _construct, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{"./isNativeReflectConstruct.js":52,"./setPrototypeOf.js":58}],47:[function(require,module,exports){
function _defineProperties(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor = props[i];
    descriptor.enumerable = descriptor.enumerable || false;
    descriptor.configurable = true;
    if ("value" in descriptor) descriptor.writable = true;
    Object.defineProperty(target, descriptor.key, descriptor);
  }
}

function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  if (staticProps) _defineProperties(Constructor, staticProps);
  Object.defineProperty(Constructor, "prototype", {
    writable: false
  });
  return Constructor;
}

module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],48:[function(require,module,exports){
function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],49:[function(require,module,exports){
var superPropBase = require("./superPropBase.js");

function _get() {
  if (typeof Reflect !== "undefined" && Reflect.get) {
    module.exports = _get = Reflect.get, module.exports.__esModule = true, module.exports["default"] = module.exports;
  } else {
    module.exports = _get = function _get(target, property, receiver) {
      var base = superPropBase(target, property);
      if (!base) return;
      var desc = Object.getOwnPropertyDescriptor(base, property);

      if (desc.get) {
        return desc.get.call(arguments.length < 3 ? target : receiver);
      }

      return desc.value;
    }, module.exports.__esModule = true, module.exports["default"] = module.exports;
  }

  return _get.apply(this, arguments);
}

module.exports = _get, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{"./superPropBase.js":60}],50:[function(require,module,exports){
function _getPrototypeOf(o) {
  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
  return _getPrototypeOf(o);
}

module.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],51:[function(require,module,exports){
var setPrototypeOf = require("./setPrototypeOf.js");

function _inherits(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function");
  }

  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      writable: true,
      configurable: true
    }
  });
  Object.defineProperty(subClass, "prototype", {
    writable: false
  });
  if (superClass) setPrototypeOf(subClass, superClass);
}

module.exports = _inherits, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{"./setPrototypeOf.js":58}],52:[function(require,module,exports){
function _isNativeReflectConstruct() {
  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
  if (Reflect.construct.sham) return false;
  if (typeof Proxy === "function") return true;

  try {
    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
    return true;
  } catch (e) {
    return false;
  }
}

module.exports = _isNativeReflectConstruct, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],53:[function(require,module,exports){
function _iterableToArray(iter) {
  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}

module.exports = _iterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],54:[function(require,module,exports){
function _iterableToArrayLimit(arr, i) {
  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];

  if (_i == null) return;
  var _arr = [];
  var _n = true;
  var _d = false;

  var _s, _e;

  try {
    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
      _arr.push(_s.value);

      if (i && _arr.length === i) break;
    }
  } catch (err) {
    _d = true;
    _e = err;
  } finally {
    try {
      if (!_n && _i["return"] != null) _i["return"]();
    } finally {
      if (_d) throw _e;
    }
  }

  return _arr;
}

module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],55:[function(require,module,exports){
function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}

module.exports = _nonIterableRest, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],56:[function(require,module,exports){
function _nonIterableSpread() {
  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}

module.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],57:[function(require,module,exports){
var _typeof = require("./typeof.js")["default"];

var assertThisInitialized = require("./assertThisInitialized.js");

function _possibleConstructorReturn(self, call) {
  if (call && (_typeof(call) === "object" || typeof call === "function")) {
    return call;
  } else if (call !== void 0) {
    throw new TypeError("Derived constructors may only return object or undefined");
  }

  return assertThisInitialized(self);
}

module.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{"./assertThisInitialized.js":40,"./typeof.js":62}],58:[function(require,module,exports){
function _setPrototypeOf(o, p) {
  module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
  return _setPrototypeOf(o, p);
}

module.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],59:[function(require,module,exports){
var arrayWithHoles = require("./arrayWithHoles.js");

var iterableToArrayLimit = require("./iterableToArrayLimit.js");

var unsupportedIterableToArray = require("./unsupportedIterableToArray.js");

var nonIterableRest = require("./nonIterableRest.js");

function _slicedToArray(arr, i) {
  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
}

module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{"./arrayWithHoles.js":38,"./iterableToArrayLimit.js":54,"./nonIterableRest.js":55,"./unsupportedIterableToArray.js":63}],60:[function(require,module,exports){
var getPrototypeOf = require("./getPrototypeOf.js");

function _superPropBase(object, property) {
  while (!Object.prototype.hasOwnProperty.call(object, property)) {
    object = getPrototypeOf(object);
    if (object === null) break;
  }

  return object;
}

module.exports = _superPropBase, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{"./getPrototypeOf.js":50}],61:[function(require,module,exports){
var arrayWithoutHoles = require("./arrayWithoutHoles.js");

var iterableToArray = require("./iterableToArray.js");

var unsupportedIterableToArray = require("./unsupportedIterableToArray.js");

var nonIterableSpread = require("./nonIterableSpread.js");

function _toConsumableArray(arr) {
  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();
}

module.exports = _toConsumableArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{"./arrayWithoutHoles.js":39,"./iterableToArray.js":53,"./nonIterableSpread.js":56,"./unsupportedIterableToArray.js":63}],62:[function(require,module,exports){
function _typeof(obj) {
  "@babel/helpers - typeof";

  return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
    return typeof obj;
  } : function (obj) {
    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
  }, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(obj);
}

module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{}],63:[function(require,module,exports){
var arrayLikeToArray = require("./arrayLikeToArray.js");

function _unsupportedIterableToArray(o, minLen) {
  if (!o) return;
  if (typeof o === "string") return arrayLikeToArray(o, minLen);
  var n = Object.prototype.toString.call(o).slice(8, -1);
  if (n === "Object" && o.constructor) n = o.constructor.name;
  if (n === "Map" || n === "Set") return Array.from(o);
  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);
}

module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{"./arrayLikeToArray.js":37}],64:[function(require,module,exports){
var AsyncGenerator = require("./AsyncGenerator.js");

function _wrapAsyncGenerator(fn) {
  return function () {
    return new AsyncGenerator(fn.apply(this, arguments));
  };
}

module.exports = _wrapAsyncGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports;
},{"./AsyncGenerator.js":35}],65:[function(require,module,exports){
module.exports = require("regenerator-runtime");

},{"regenerator-runtime":730}],66:[function(require,module,exports){
"use strict";
module.exports = asPromise;

/**
 * Callback as used by {@link util.asPromise}.
 * @typedef asPromiseCallback
 * @type {function}
 * @param {Error|null} error Error, if any
 * @param {...*} params Additional arguments
 * @returns {undefined}
 */

/**
 * Returns a promise from a node-style callback function.
 * @memberof util
 * @param {asPromiseCallback} fn Function to call
 * @param {*} ctx Function context
 * @param {...*} params Function arguments
 * @returns {Promise<*>} Promisified function
 */
function asPromise(fn, ctx/*, varargs */) {
    var params  = new Array(arguments.length - 1),
        offset  = 0,
        index   = 2,
        pending = true;
    while (index < arguments.length)
        params[offset++] = arguments[index++];
    return new Promise(function executor(resolve, reject) {
        params[offset] = function callback(err/*, varargs */) {
            if (pending) {
                pending = false;
                if (err)
                    reject(err);
                else {
                    var params = new Array(arguments.length - 1),
                        offset = 0;
                    while (offset < params.length)
                        params[offset++] = arguments[offset];
                    resolve.apply(null, params);
                }
            }
        };
        try {
            fn.apply(ctx || null, params);
        } catch (err) {
            if (pending) {
                pending = false;
                reject(err);
            }
        }
    });
}

},{}],67:[function(require,module,exports){
"use strict";

/**
 * A minimal base64 implementation for number arrays.
 * @memberof util
 * @namespace
 */
var base64 = exports;

/**
 * Calculates the byte length of a base64 encoded string.
 * @param {string} string Base64 encoded string
 * @returns {number} Byte length
 */
base64.length = function length(string) {
    var p = string.length;
    if (!p)
        return 0;
    var n = 0;
    while (--p % 4 > 1 && string.charAt(p) === "=")
        ++n;
    return Math.ceil(string.length * 3) / 4 - n;
};

// Base64 encoding table
var b64 = new Array(64);

// Base64 decoding table
var s64 = new Array(123);

// 65..90, 97..122, 48..57, 43, 47
for (var i = 0; i < 64;)
    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;

/**
 * Encodes a buffer to a base64 encoded string.
 * @param {Uint8Array} buffer Source buffer
 * @param {number} start Source start
 * @param {number} end Source end
 * @returns {string} Base64 encoded string
 */
base64.encode = function encode(buffer, start, end) {
    var parts = null,
        chunk = [];
    var i = 0, // output index
        j = 0, // goto index
        t;     // temporary
    while (start < end) {
        var b = buffer[start++];
        switch (j) {
            case 0:
                chunk[i++] = b64[b >> 2];
                t = (b & 3) << 4;
                j = 1;
                break;
            case 1:
                chunk[i++] = b64[t | b >> 4];
                t = (b & 15) << 2;
                j = 2;
                break;
            case 2:
                chunk[i++] = b64[t | b >> 6];
                chunk[i++] = b64[b & 63];
                j = 0;
                break;
        }
        if (i > 8191) {
            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
            i = 0;
        }
    }
    if (j) {
        chunk[i++] = b64[t];
        chunk[i++] = 61;
        if (j === 1)
            chunk[i++] = 61;
    }
    if (parts) {
        if (i)
            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
        return parts.join("");
    }
    return String.fromCharCode.apply(String, chunk.slice(0, i));
};

var invalidEncoding = "invalid encoding";

/**
 * Decodes a base64 encoded string to a buffer.
 * @param {string} string Source string
 * @param {Uint8Array} buffer Destination buffer
 * @param {number} offset Destination offset
 * @returns {number} Number of bytes written
 * @throws {Error} If encoding is invalid
 */
base64.decode = function decode(string, buffer, offset) {
    var start = offset;
    var j = 0, // goto index
        t;     // temporary
    for (var i = 0; i < string.length;) {
        var c = string.charCodeAt(i++);
        if (c === 61 && j > 1)
            break;
        if ((c = s64[c]) === undefined)
            throw Error(invalidEncoding);
        switch (j) {
            case 0:
                t = c;
                j = 1;
                break;
            case 1:
                buffer[offset++] = t << 2 | (c & 48) >> 4;
                t = c;
                j = 2;
                break;
            case 2:
                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
                t = c;
                j = 3;
                break;
            case 3:
                buffer[offset++] = (t & 3) << 6 | c;
                j = 0;
                break;
        }
    }
    if (j === 1)
        throw Error(invalidEncoding);
    return offset - start;
};

/**
 * Tests if the specified string appears to be base64 encoded.
 * @param {string} string String to test
 * @returns {boolean} `true` if probably base64 encoded, otherwise false
 */
base64.test = function test(string) {
    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
};

},{}],68:[function(require,module,exports){
"use strict";
module.exports = EventEmitter;

/**
 * Constructs a new event emitter instance.
 * @classdesc A minimal event emitter.
 * @memberof util
 * @constructor
 */
function EventEmitter() {

    /**
     * Registered listeners.
     * @type {Object.<string,*>}
     * @private
     */
    this._listeners = {};
}

/**
 * Registers an event listener.
 * @param {string} evt Event name
 * @param {function} fn Listener
 * @param {*} [ctx] Listener context
 * @returns {util.EventEmitter} `this`
 */
EventEmitter.prototype.on = function on(evt, fn, ctx) {
    (this._listeners[evt] || (this._listeners[evt] = [])).push({
        fn  : fn,
        ctx : ctx || this
    });
    return this;
};

/**
 * Removes an event listener or any matching listeners if arguments are omitted.
 * @param {string} [evt] Event name. Removes all listeners if omitted.
 * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
 * @returns {util.EventEmitter} `this`
 */
EventEmitter.prototype.off = function off(evt, fn) {
    if (evt === undefined)
        this._listeners = {};
    else {
        if (fn === undefined)
            this._listeners[evt] = [];
        else {
            var listeners = this._listeners[evt];
            for (var i = 0; i < listeners.length;)
                if (listeners[i].fn === fn)
                    listeners.splice(i, 1);
                else
                    ++i;
        }
    }
    return this;
};

/**
 * Emits an event by calling its listeners with the specified arguments.
 * @param {string} evt Event name
 * @param {...*} args Arguments
 * @returns {util.EventEmitter} `this`
 */
EventEmitter.prototype.emit = function emit(evt) {
    var listeners = this._listeners[evt];
    if (listeners) {
        var args = [],
            i = 1;
        for (; i < arguments.length;)
            args.push(arguments[i++]);
        for (i = 0; i < listeners.length;)
            listeners[i].fn.apply(listeners[i++].ctx, args);
    }
    return this;
};

},{}],69:[function(require,module,exports){
"use strict";

module.exports = factory(factory);

/**
 * Reads / writes floats / doubles from / to buffers.
 * @name util.float
 * @namespace
 */

/**
 * Writes a 32 bit float to a buffer using little endian byte order.
 * @name util.float.writeFloatLE
 * @function
 * @param {number} val Value to write
 * @param {Uint8Array} buf Target buffer
 * @param {number} pos Target buffer offset
 * @returns {undefined}
 */

/**
 * Writes a 32 bit float to a buffer using big endian byte order.
 * @name util.float.writeFloatBE
 * @function
 * @param {number} val Value to write
 * @param {Uint8Array} buf Target buffer
 * @param {number} pos Target buffer offset
 * @returns {undefined}
 */

/**
 * Reads a 32 bit float from a buffer using little endian byte order.
 * @name util.float.readFloatLE
 * @function
 * @param {Uint8Array} buf Source buffer
 * @param {number} pos Source buffer offset
 * @returns {number} Value read
 */

/**
 * Reads a 32 bit float from a buffer using big endian byte order.
 * @name util.float.readFloatBE
 * @function
 * @param {Uint8Array} buf Source buffer
 * @param {number} pos Source buffer offset
 * @returns {number} Value read
 */

/**
 * Writes a 64 bit double to a buffer using little endian byte order.
 * @name util.float.writeDoubleLE
 * @function
 * @param {number} val Value to write
 * @param {Uint8Array} buf Target buffer
 * @param {number} pos Target buffer offset
 * @returns {undefined}
 */

/**
 * Writes a 64 bit double to a buffer using big endian byte order.
 * @name util.float.writeDoubleBE
 * @function
 * @param {number} val Value to write
 * @param {Uint8Array} buf Target buffer
 * @param {number} pos Target buffer offset
 * @returns {undefined}
 */

/**
 * Reads a 64 bit double from a buffer using little endian byte order.
 * @name util.float.readDoubleLE
 * @function
 * @param {Uint8Array} buf Source buffer
 * @param {number} pos Source buffer offset
 * @returns {number} Value read
 */

/**
 * Reads a 64 bit double from a buffer using big endian byte order.
 * @name util.float.readDoubleBE
 * @function
 * @param {Uint8Array} buf Source buffer
 * @param {number} pos Source buffer offset
 * @returns {number} Value read
 */

// Factory function for the purpose of node-based testing in modified global environments
function factory(exports) {

    // float: typed array
    if (typeof Float32Array !== "undefined") (function() {

        var f32 = new Float32Array([ -0 ]),
            f8b = new Uint8Array(f32.buffer),
            le  = f8b[3] === 128;

        function writeFloat_f32_cpy(val, buf, pos) {
            f32[0] = val;
            buf[pos    ] = f8b[0];
            buf[pos + 1] = f8b[1];
            buf[pos + 2] = f8b[2];
            buf[pos + 3] = f8b[3];
        }

        function writeFloat_f32_rev(val, buf, pos) {
            f32[0] = val;
            buf[pos    ] = f8b[3];
            buf[pos + 1] = f8b[2];
            buf[pos + 2] = f8b[1];
            buf[pos + 3] = f8b[0];
        }

        /* istanbul ignore next */
        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
        /* istanbul ignore next */
        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;

        function readFloat_f32_cpy(buf, pos) {
            f8b[0] = buf[pos    ];
            f8b[1] = buf[pos + 1];
            f8b[2] = buf[pos + 2];
            f8b[3] = buf[pos + 3];
            return f32[0];
        }

        function readFloat_f32_rev(buf, pos) {
            f8b[3] = buf[pos    ];
            f8b[2] = buf[pos + 1];
            f8b[1] = buf[pos + 2];
            f8b[0] = buf[pos + 3];
            return f32[0];
        }

        /* istanbul ignore next */
        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
        /* istanbul ignore next */
        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;

    // float: ieee754
    })(); else (function() {

        function writeFloat_ieee754(writeUint, val, buf, pos) {
            var sign = val < 0 ? 1 : 0;
            if (sign)
                val = -val;
            if (val === 0)
                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);
            else if (isNaN(val))
                writeUint(2143289344, buf, pos);
            else if (val > 3.4028234663852886e+38) // +-Infinity
                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
            else if (val < 1.1754943508222875e-38) // denormal
                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);
            else {
                var exponent = Math.floor(Math.log(val) / Math.LN2),
                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
            }
        }

        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);

        function readFloat_ieee754(readUint, buf, pos) {
            var uint = readUint(buf, pos),
                sign = (uint >> 31) * 2 + 1,
                exponent = uint >>> 23 & 255,
                mantissa = uint & 8388607;
            return exponent === 255
                ? mantissa
                ? NaN
                : sign * Infinity
                : exponent === 0 // denormal
                ? sign * 1.401298464324817e-45 * mantissa
                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
        }

        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);

    })();

    // double: typed array
    if (typeof Float64Array !== "undefined") (function() {

        var f64 = new Float64Array([-0]),
            f8b = new Uint8Array(f64.buffer),
            le  = f8b[7] === 128;

        function writeDouble_f64_cpy(val, buf, pos) {
            f64[0] = val;
            buf[pos    ] = f8b[0];
            buf[pos + 1] = f8b[1];
            buf[pos + 2] = f8b[2];
            buf[pos + 3] = f8b[3];
            buf[pos + 4] = f8b[4];
            buf[pos + 5] = f8b[5];
            buf[pos + 6] = f8b[6];
            buf[pos + 7] = f8b[7];
        }

        function writeDouble_f64_rev(val, buf, pos) {
            f64[0] = val;
            buf[pos    ] = f8b[7];
            buf[pos + 1] = f8b[6];
            buf[pos + 2] = f8b[5];
            buf[pos + 3] = f8b[4];
            buf[pos + 4] = f8b[3];
            buf[pos + 5] = f8b[2];
            buf[pos + 6] = f8b[1];
            buf[pos + 7] = f8b[0];
        }

        /* istanbul ignore next */
        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
        /* istanbul ignore next */
        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;

        function readDouble_f64_cpy(buf, pos) {
            f8b[0] = buf[pos    ];
            f8b[1] = buf[pos + 1];
            f8b[2] = buf[pos + 2];
            f8b[3] = buf[pos + 3];
            f8b[4] = buf[pos + 4];
            f8b[5] = buf[pos + 5];
            f8b[6] = buf[pos + 6];
            f8b[7] = buf[pos + 7];
            return f64[0];
        }

        function readDouble_f64_rev(buf, pos) {
            f8b[7] = buf[pos    ];
            f8b[6] = buf[pos + 1];
            f8b[5] = buf[pos + 2];
            f8b[4] = buf[pos + 3];
            f8b[3] = buf[pos + 4];
            f8b[2] = buf[pos + 5];
            f8b[1] = buf[pos + 6];
            f8b[0] = buf[pos + 7];
            return f64[0];
        }

        /* istanbul ignore next */
        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
        /* istanbul ignore next */
        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;

    // double: ieee754
    })(); else (function() {

        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
            var sign = val < 0 ? 1 : 0;
            if (sign)
                val = -val;
            if (val === 0) {
                writeUint(0, buf, pos + off0);
                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);
            } else if (isNaN(val)) {
                writeUint(0, buf, pos + off0);
                writeUint(2146959360, buf, pos + off1);
            } else if (val > 1.7976931348623157e+308) { // +-Infinity
                writeUint(0, buf, pos + off0);
                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
            } else {
                var mantissa;
                if (val < 2.2250738585072014e-308) { // denormal
                    mantissa = val / 5e-324;
                    writeUint(mantissa >>> 0, buf, pos + off0);
                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
                } else {
                    var exponent = Math.floor(Math.log(val) / Math.LN2);
                    if (exponent === 1024)
                        exponent = 1023;
                    mantissa = val * Math.pow(2, -exponent);
                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
                }
            }
        }

        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);

        function readDouble_ieee754(readUint, off0, off1, buf, pos) {
            var lo = readUint(buf, pos + off0),
                hi = readUint(buf, pos + off1);
            var sign = (hi >> 31) * 2 + 1,
                exponent = hi >>> 20 & 2047,
                mantissa = 4294967296 * (hi & 1048575) + lo;
            return exponent === 2047
                ? mantissa
                ? NaN
                : sign * Infinity
                : exponent === 0 // denormal
                ? sign * 5e-324 * mantissa
                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
        }

        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);

    })();

    return exports;
}

// uint helpers

function writeUintLE(val, buf, pos) {
    buf[pos    ] =  val        & 255;
    buf[pos + 1] =  val >>> 8  & 255;
    buf[pos + 2] =  val >>> 16 & 255;
    buf[pos + 3] =  val >>> 24;
}

function writeUintBE(val, buf, pos) {
    buf[pos    ] =  val >>> 24;
    buf[pos + 1] =  val >>> 16 & 255;
    buf[pos + 2] =  val >>> 8  & 255;
    buf[pos + 3] =  val        & 255;
}

function readUintLE(buf, pos) {
    return (buf[pos    ]
          | buf[pos + 1] << 8
          | buf[pos + 2] << 16
          | buf[pos + 3] << 24) >>> 0;
}

function readUintBE(buf, pos) {
    return (buf[pos    ] << 24
          | buf[pos + 1] << 16
          | buf[pos + 2] << 8
          | buf[pos + 3]) >>> 0;
}

},{}],70:[function(require,module,exports){
"use strict";
module.exports = inquire;

/**
 * Requires a module only if available.
 * @memberof util
 * @param {string} moduleName Module to require
 * @returns {?Object} Required module if available and not empty, otherwise `null`
 */
function inquire(moduleName) {
    try {
        var mod = eval("quire".replace(/^/,"re"))(moduleName); // eslint-disable-line no-eval
        if (mod && (mod.length || Object.keys(mod).length))
            return mod;
    } catch (e) {} // eslint-disable-line no-empty
    return null;
}

},{}],71:[function(require,module,exports){
"use strict";
module.exports = pool;

/**
 * An allocator as used by {@link util.pool}.
 * @typedef PoolAllocator
 * @type {function}
 * @param {number} size Buffer size
 * @returns {Uint8Array} Buffer
 */

/**
 * A slicer as used by {@link util.pool}.
 * @typedef PoolSlicer
 * @type {function}
 * @param {number} start Start offset
 * @param {number} end End offset
 * @returns {Uint8Array} Buffer slice
 * @this {Uint8Array}
 */

/**
 * A general purpose buffer pool.
 * @memberof util
 * @function
 * @param {PoolAllocator} alloc Allocator
 * @param {PoolSlicer} slice Slicer
 * @param {number} [size=8192] Slab size
 * @returns {PoolAllocator} Pooled allocator
 */
function pool(alloc, slice, size) {
    var SIZE   = size || 8192;
    var MAX    = SIZE >>> 1;
    var slab   = null;
    var offset = SIZE;
    return function pool_alloc(size) {
        if (size < 1 || size > MAX)
            return alloc(size);
        if (offset + size > SIZE) {
            slab = alloc(SIZE);
            offset = 0;
        }
        var buf = slice.call(slab, offset, offset += size);
        if (offset & 7) // align to 32 bit
            offset = (offset | 7) + 1;
        return buf;
    };
}

},{}],72:[function(require,module,exports){
"use strict";

/**
 * A minimal UTF8 implementation for number arrays.
 * @memberof util
 * @namespace
 */
var utf8 = exports;

/**
 * Calculates the UTF8 byte length of a string.
 * @param {string} string String
 * @returns {number} Byte length
 */
utf8.length = function utf8_length(string) {
    var len = 0,
        c = 0;
    for (var i = 0; i < string.length; ++i) {
        c = string.charCodeAt(i);
        if (c < 128)
            len += 1;
        else if (c < 2048)
            len += 2;
        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {
            ++i;
            len += 4;
        } else
            len += 3;
    }
    return len;
};

/**
 * Reads UTF8 bytes as a string.
 * @param {Uint8Array} buffer Source buffer
 * @param {number} start Source start
 * @param {number} end Source end
 * @returns {string} String read
 */
utf8.read = function utf8_read(buffer, start, end) {
    var len = end - start;
    if (len < 1)
        return "";
    var parts = null,
        chunk = [],
        i = 0, // char offset
        t;     // temporary
    while (start < end) {
        t = buffer[start++];
        if (t < 128)
            chunk[i++] = t;
        else if (t > 191 && t < 224)
            chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
        else if (t > 239 && t < 365) {
            t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;
            chunk[i++] = 0xD800 + (t >> 10);
            chunk[i++] = 0xDC00 + (t & 1023);
        } else
            chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
        if (i > 8191) {
            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
            i = 0;
        }
    }
    if (parts) {
        if (i)
            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
        return parts.join("");
    }
    return String.fromCharCode.apply(String, chunk.slice(0, i));
};

/**
 * Writes a string as UTF8 bytes.
 * @param {string} string Source string
 * @param {Uint8Array} buffer Destination buffer
 * @param {number} offset Destination offset
 * @returns {number} Bytes written
 */
utf8.write = function utf8_write(string, buffer, offset) {
    var start = offset,
        c1, // character 1
        c2; // character 2
    for (var i = 0; i < string.length; ++i) {
        c1 = string.charCodeAt(i);
        if (c1 < 128) {
            buffer[offset++] = c1;
        } else if (c1 < 2048) {
            buffer[offset++] = c1 >> 6       | 192;
            buffer[offset++] = c1       & 63 | 128;
        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {
            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);
            ++i;
            buffer[offset++] = c1 >> 18      | 240;
            buffer[offset++] = c1 >> 12 & 63 | 128;
            buffer[offset++] = c1 >> 6  & 63 | 128;
            buffer[offset++] = c1       & 63 | 128;
        } else {
            buffer[offset++] = c1 >> 12      | 224;
            buffer[offset++] = c1 >> 6  & 63 | 128;
            buffer[offset++] = c1       & 63 | 128;
        }
    }
    return offset - start;
};

},{}],73:[function(require,module,exports){
(function (global){(function (){
'use strict';

var objectAssign = require('object-assign');

// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js
// original notice:

/*!
 * The buffer module from node.js, for the browser.
 *
 * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
 * @license  MIT
 */
function compare(a, b) {
  if (a === b) {
    return 0;
  }

  var x = a.length;
  var y = b.length;

  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
    if (a[i] !== b[i]) {
      x = a[i];
      y = b[i];
      break;
    }
  }

  if (x < y) {
    return -1;
  }
  if (y < x) {
    return 1;
  }
  return 0;
}
function isBuffer(b) {
  if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {
    return global.Buffer.isBuffer(b);
  }
  return !!(b != null && b._isBuffer);
}

// based on node assert, original notice:
// NB: The URL to the CommonJS spec is kept just for tradition.
//     node-assert has evolved a lot since then, both in API and behavior.

// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
//
// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
//
// Originally from narwhal.js (http://narwhaljs.org)
// Copyright (c) 2009 Thomas Robinson <280north.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the 'Software'), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

var util = require('util/');
var hasOwn = Object.prototype.hasOwnProperty;
var pSlice = Array.prototype.slice;
var functionsHaveNames = (function () {
  return function foo() {}.name === 'foo';
}());
function pToString (obj) {
  return Object.prototype.toString.call(obj);
}
function isView(arrbuf) {
  if (isBuffer(arrbuf)) {
    return false;
  }
  if (typeof global.ArrayBuffer !== 'function') {
    return false;
  }
  if (typeof ArrayBuffer.isView === 'function') {
    return ArrayBuffer.isView(arrbuf);
  }
  if (!arrbuf) {
    return false;
  }
  if (arrbuf instanceof DataView) {
    return true;
  }
  if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {
    return true;
  }
  return false;
}
// 1. The assert module provides functions that throw
// AssertionError's when particular conditions are not met. The
// assert module must conform to the following interface.

var assert = module.exports = ok;

// 2. The AssertionError is defined in assert.
// new assert.AssertionError({ message: message,
//                             actual: actual,
//                             expected: expected })

var regex = /\s*function\s+([^\(\s]*)\s*/;
// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js
function getName(func) {
  if (!util.isFunction(func)) {
    return;
  }
  if (functionsHaveNames) {
    return func.name;
  }
  var str = func.toString();
  var match = str.match(regex);
  return match && match[1];
}
assert.AssertionError = function AssertionError(options) {
  this.name = 'AssertionError';
  this.actual = options.actual;
  this.expected = options.expected;
  this.operator = options.operator;
  if (options.message) {
    this.message = options.message;
    this.generatedMessage = false;
  } else {
    this.message = getMessage(this);
    this.generatedMessage = true;
  }
  var stackStartFunction = options.stackStartFunction || fail;
  if (Error.captureStackTrace) {
    Error.captureStackTrace(this, stackStartFunction);
  } else {
    // non v8 browsers so we can have a stacktrace
    var err = new Error();
    if (err.stack) {
      var out = err.stack;

      // try to strip useless frames
      var fn_name = getName(stackStartFunction);
      var idx = out.indexOf('\n' + fn_name);
      if (idx >= 0) {
        // once we have located the function frame
        // we need to strip out everything before it (and its line)
        var next_line = out.indexOf('\n', idx + 1);
        out = out.substring(next_line + 1);
      }

      this.stack = out;
    }
  }
};

// assert.AssertionError instanceof Error
util.inherits(assert.AssertionError, Error);

function truncate(s, n) {
  if (typeof s === 'string') {
    return s.length < n ? s : s.slice(0, n);
  } else {
    return s;
  }
}
function inspect(something) {
  if (functionsHaveNames || !util.isFunction(something)) {
    return util.inspect(something);
  }
  var rawname = getName(something);
  var name = rawname ? ': ' + rawname : '';
  return '[Function' +  name + ']';
}
function getMessage(self) {
  return truncate(inspect(self.actual), 128) + ' ' +
         self.operator + ' ' +
         truncate(inspect(self.expected), 128);
}

// At present only the three keys mentioned above are used and
// understood by the spec. Implementations or sub modules can pass
// other keys to the AssertionError's constructor - they will be
// ignored.

// 3. All of the following functions must throw an AssertionError
// when a corresponding condition is not met, with a message that
// may be undefined if not provided.  All assertion methods provide
// both the actual and expected values to the assertion error for
// display purposes.

function fail(actual, expected, message, operator, stackStartFunction) {
  throw new assert.AssertionError({
    message: message,
    actual: actual,
    expected: expected,
    operator: operator,
    stackStartFunction: stackStartFunction
  });
}

// EXTENSION! allows for well behaved errors defined elsewhere.
assert.fail = fail;

// 4. Pure assertion tests whether a value is truthy, as determined
// by !!guard.
// assert.ok(guard, message_opt);
// This statement is equivalent to assert.equal(true, !!guard,
// message_opt);. To test strictly for the value true, use
// assert.strictEqual(true, guard, message_opt);.

function ok(value, message) {
  if (!value) fail(value, true, message, '==', assert.ok);
}
assert.ok = ok;

// 5. The equality assertion tests shallow, coercive equality with
// ==.
// assert.equal(actual, expected, message_opt);

assert.equal = function equal(actual, expected, message) {
  if (actual != expected) fail(actual, expected, message, '==', assert.equal);
};

// 6. The non-equality assertion tests for whether two objects are not equal
// with != assert.notEqual(actual, expected, message_opt);

assert.notEqual = function notEqual(actual, expected, message) {
  if (actual == expected) {
    fail(actual, expected, message, '!=', assert.notEqual);
  }
};

// 7. The equivalence assertion tests a deep equality relation.
// assert.deepEqual(actual, expected, message_opt);

assert.deepEqual = function deepEqual(actual, expected, message) {
  if (!_deepEqual(actual, expected, false)) {
    fail(actual, expected, message, 'deepEqual', assert.deepEqual);
  }
};

assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
  if (!_deepEqual(actual, expected, true)) {
    fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);
  }
};

function _deepEqual(actual, expected, strict, memos) {
  // 7.1. All identical values are equivalent, as determined by ===.
  if (actual === expected) {
    return true;
  } else if (isBuffer(actual) && isBuffer(expected)) {
    return compare(actual, expected) === 0;

  // 7.2. If the expected value is a Date object, the actual value is
  // equivalent if it is also a Date object that refers to the same time.
  } else if (util.isDate(actual) && util.isDate(expected)) {
    return actual.getTime() === expected.getTime();

  // 7.3 If the expected value is a RegExp object, the actual value is
  // equivalent if it is also a RegExp object with the same source and
  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
    return actual.source === expected.source &&
           actual.global === expected.global &&
           actual.multiline === expected.multiline &&
           actual.lastIndex === expected.lastIndex &&
           actual.ignoreCase === expected.ignoreCase;

  // 7.4. Other pairs that do not both pass typeof value == 'object',
  // equivalence is determined by ==.
  } else if ((actual === null || typeof actual !== 'object') &&
             (expected === null || typeof expected !== 'object')) {
    return strict ? actual === expected : actual == expected;

  // If both values are instances of typed arrays, wrap their underlying
  // ArrayBuffers in a Buffer each to increase performance
  // This optimization requires the arrays to have the same type as checked by
  // Object.prototype.toString (aka pToString). Never perform binary
  // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their
  // bit patterns are not identical.
  } else if (isView(actual) && isView(expected) &&
             pToString(actual) === pToString(expected) &&
             !(actual instanceof Float32Array ||
               actual instanceof Float64Array)) {
    return compare(new Uint8Array(actual.buffer),
                   new Uint8Array(expected.buffer)) === 0;

  // 7.5 For all other Object pairs, including Array objects, equivalence is
  // determined by having the same number of owned properties (as verified
  // with Object.prototype.hasOwnProperty.call), the same set of keys
  // (although not necessarily the same order), equivalent values for every
  // corresponding key, and an identical 'prototype' property. Note: this
  // accounts for both named and indexed properties on Arrays.
  } else if (isBuffer(actual) !== isBuffer(expected)) {
    return false;
  } else {
    memos = memos || {actual: [], expected: []};

    var actualIndex = memos.actual.indexOf(actual);
    if (actualIndex !== -1) {
      if (actualIndex === memos.expected.indexOf(expected)) {
        return true;
      }
    }

    memos.actual.push(actual);
    memos.expected.push(expected);

    return objEquiv(actual, expected, strict, memos);
  }
}

function isArguments(object) {
  return Object.prototype.toString.call(object) == '[object Arguments]';
}

function objEquiv(a, b, strict, actualVisitedObjects) {
  if (a === null || a === undefined || b === null || b === undefined)
    return false;
  // if one is a primitive, the other must be same
  if (util.isPrimitive(a) || util.isPrimitive(b))
    return a === b;
  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
    return false;
  var aIsArgs = isArguments(a);
  var bIsArgs = isArguments(b);
  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
    return false;
  if (aIsArgs) {
    a = pSlice.call(a);
    b = pSlice.call(b);
    return _deepEqual(a, b, strict);
  }
  var ka = objectKeys(a);
  var kb = objectKeys(b);
  var key, i;
  // having the same number of owned properties (keys incorporates
  // hasOwnProperty)
  if (ka.length !== kb.length)
    return false;
  //the same set of keys (although not necessarily the same order),
  ka.sort();
  kb.sort();
  //~~~cheap key test
  for (i = ka.length - 1; i >= 0; i--) {
    if (ka[i] !== kb[i])
      return false;
  }
  //equivalent values for every corresponding key, and
  //~~~possibly expensive deep test
  for (i = ka.length - 1; i >= 0; i--) {
    key = ka[i];
    if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))
      return false;
  }
  return true;
}

// 8. The non-equivalence assertion tests for any deep inequality.
// assert.notDeepEqual(actual, expected, message_opt);

assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
  if (_deepEqual(actual, expected, false)) {
    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
  }
};

assert.notDeepStrictEqual = notDeepStrictEqual;
function notDeepStrictEqual(actual, expected, message) {
  if (_deepEqual(actual, expected, true)) {
    fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);
  }
}


// 9. The strict equality assertion tests strict equality, as determined by ===.
// assert.strictEqual(actual, expected, message_opt);

assert.strictEqual = function strictEqual(actual, expected, message) {
  if (actual !== expected) {
    fail(actual, expected, message, '===', assert.strictEqual);
  }
};

// 10. The strict non-equality assertion tests for strict inequality, as
// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);

assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
  if (actual === expected) {
    fail(actual, expected, message, '!==', assert.notStrictEqual);
  }
};

function expectedException(actual, expected) {
  if (!actual || !expected) {
    return false;
  }

  if (Object.prototype.toString.call(expected) == '[object RegExp]') {
    return expected.test(actual);
  }

  try {
    if (actual instanceof expected) {
      return true;
    }
  } catch (e) {
    // Ignore.  The instanceof check doesn't work for arrow functions.
  }

  if (Error.isPrototypeOf(expected)) {
    return false;
  }

  return expected.call({}, actual) === true;
}

function _tryBlock(block) {
  var error;
  try {
    block();
  } catch (e) {
    error = e;
  }
  return error;
}

function _throws(shouldThrow, block, expected, message) {
  var actual;

  if (typeof block !== 'function') {
    throw new TypeError('"block" argument must be a function');
  }

  if (typeof expected === 'string') {
    message = expected;
    expected = null;
  }

  actual = _tryBlock(block);

  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
            (message ? ' ' + message : '.');

  if (shouldThrow && !actual) {
    fail(actual, expected, 'Missing expected exception' + message);
  }

  var userProvidedMessage = typeof message === 'string';
  var isUnwantedException = !shouldThrow && util.isError(actual);
  var isUnexpectedException = !shouldThrow && actual && !expected;

  if ((isUnwantedException &&
      userProvidedMessage &&
      expectedException(actual, expected)) ||
      isUnexpectedException) {
    fail(actual, expected, 'Got unwanted exception' + message);
  }

  if ((shouldThrow && actual && expected &&
      !expectedException(actual, expected)) || (!shouldThrow && actual)) {
    throw actual;
  }
}

// 11. Expected to throw an error:
// assert.throws(block, Error_opt, message_opt);

assert.throws = function(block, /*optional*/error, /*optional*/message) {
  _throws(true, block, error, message);
};

// EXTENSION! This is annoying to write outside this module.
assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {
  _throws(false, block, error, message);
};

assert.ifError = function(err) { if (err) throw err; };

// Expose a strict only variant of assert
function strict(value, message) {
  if (!value) fail(value, true, message, '==', strict);
}
assert.strict = objectAssign(strict, assert, {
  equal: assert.strictEqual,
  deepEqual: assert.deepStrictEqual,
  notEqual: assert.notStrictEqual,
  notDeepEqual: assert.notDeepStrictEqual
});
assert.strict.strict = assert.strict;

var objectKeys = Object.keys || function (obj) {
  var keys = [];
  for (var key in obj) {
    if (hasOwn.call(obj, key)) keys.push(key);
  }
  return keys;
};

}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{"object-assign":713,"util/":76}],74:[function(require,module,exports){
if (typeof Object.create === 'function') {
  // implementation from standard node.js 'util' module
  module.exports = function inherits(ctor, superCtor) {
    ctor.super_ = superCtor
    ctor.prototype = Object.create(superCtor.prototype, {
      constructor: {
        value: ctor,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
  };
} else {
  // old school shim for old browsers
  module.exports = function inherits(ctor, superCtor) {
    ctor.super_ = superCtor
    var TempCtor = function () {}
    TempCtor.prototype = superCtor.prototype
    ctor.prototype = new TempCtor()
    ctor.prototype.constructor = ctor
  }
}

},{}],75:[function(require,module,exports){
module.exports = function isBuffer(arg) {
  return arg && typeof arg === 'object'
    && typeof arg.copy === 'function'
    && typeof arg.fill === 'function'
    && typeof arg.readUInt8 === 'function';
}
},{}],76:[function(require,module,exports){
(function (process,global){(function (){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

var formatRegExp = /%[sdj%]/g;
exports.format = function(f) {
  if (!isString(f)) {
    var objects = [];
    for (var i = 0; i < arguments.length; i++) {
      objects.push(inspect(arguments[i]));
    }
    return objects.join(' ');
  }

  var i = 1;
  var args = arguments;
  var len = args.length;
  var str = String(f).replace(formatRegExp, function(x) {
    if (x === '%%') return '%';
    if (i >= len) return x;
    switch (x) {
      case '%s': return String(args[i++]);
      case '%d': return Number(args[i++]);
      case '%j':
        try {
          return JSON.stringify(args[i++]);
        } catch (_) {
          return '[Circular]';
        }
      default:
        return x;
    }
  });
  for (var x = args[i]; i < len; x = args[++i]) {
    if (isNull(x) || !isObject(x)) {
      str += ' ' + x;
    } else {
      str += ' ' + inspect(x);
    }
  }
  return str;
};


// Mark that a method should not be used.
// Returns a modified function which warns once by default.
// If --no-deprecation is set, then it is a no-op.
exports.deprecate = function(fn, msg) {
  // Allow for deprecating things in the process of starting up.
  if (isUndefined(global.process)) {
    return function() {
      return exports.deprecate(fn, msg).apply(this, arguments);
    };
  }

  if (process.noDeprecation === true) {
    return fn;
  }

  var warned = false;
  function deprecated() {
    if (!warned) {
      if (process.throwDeprecation) {
        throw new Error(msg);
      } else if (process.traceDeprecation) {
        console.trace(msg);
      } else {
        console.error(msg);
      }
      warned = true;
    }
    return fn.apply(this, arguments);
  }

  return deprecated;
};


var debugs = {};
var debugEnviron;
exports.debuglog = function(set) {
  if (isUndefined(debugEnviron))
    debugEnviron = process.env.NODE_DEBUG || '';
  set = set.toUpperCase();
  if (!debugs[set]) {
    if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
      var pid = process.pid;
      debugs[set] = function() {
        var msg = exports.format.apply(exports, arguments);
        console.error('%s %d: %s', set, pid, msg);
      };
    } else {
      debugs[set] = function() {};
    }
  }
  return debugs[set];
};


/**
 * Echos the value of a value. Trys to print the value out
 * in the best way possible given the different types.
 *
 * @param {Object} obj The object to print out.
 * @param {Object} opts Optional options object that alters the output.
 */
/* legacy: obj, showHidden, depth, colors*/
function inspect(obj, opts) {
  // default options
  var ctx = {
    seen: [],
    stylize: stylizeNoColor
  };
  // legacy...
  if (arguments.length >= 3) ctx.depth = arguments[2];
  if (arguments.length >= 4) ctx.colors = arguments[3];
  if (isBoolean(opts)) {
    // legacy...
    ctx.showHidden = opts;
  } else if (opts) {
    // got an "options" object
    exports._extend(ctx, opts);
  }
  // set default options
  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
  if (isUndefined(ctx.depth)) ctx.depth = 2;
  if (isUndefined(ctx.colors)) ctx.colors = false;
  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
  if (ctx.colors) ctx.stylize = stylizeWithColor;
  return formatValue(ctx, obj, ctx.depth);
}
exports.inspect = inspect;


// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
inspect.colors = {
  'bold' : [1, 22],
  'italic' : [3, 23],
  'underline' : [4, 24],
  'inverse' : [7, 27],
  'white' : [37, 39],
  'grey' : [90, 39],
  'black' : [30, 39],
  'blue' : [34, 39],
  'cyan' : [36, 39],
  'green' : [32, 39],
  'magenta' : [35, 39],
  'red' : [31, 39],
  'yellow' : [33, 39]
};

// Don't use 'blue' not visible on cmd.exe
inspect.styles = {
  'special': 'cyan',
  'number': 'yellow',
  'boolean': 'yellow',
  'undefined': 'grey',
  'null': 'bold',
  'string': 'green',
  'date': 'magenta',
  // "name": intentionally not styling
  'regexp': 'red'
};


function stylizeWithColor(str, styleType) {
  var style = inspect.styles[styleType];

  if (style) {
    return '\u001b[' + inspect.colors[style][0] + 'm' + str +
           '\u001b[' + inspect.colors[style][1] + 'm';
  } else {
    return str;
  }
}


function stylizeNoColor(str, styleType) {
  return str;
}


function arrayToHash(array) {
  var hash = {};

  array.forEach(function(val, idx) {
    hash[val] = true;
  });

  return hash;
}


function formatValue(ctx, value, recurseTimes) {
  // Provide a hook for user-specified inspect functions.
  // Check that value is an object with an inspect function on it
  if (ctx.customInspect &&
      value &&
      isFunction(value.inspect) &&
      // Filter out the util module, it's inspect function is special
      value.inspect !== exports.inspect &&
      // Also filter out any prototype objects using the circular check.
      !(value.constructor && value.constructor.prototype === value)) {
    var ret = value.inspect(recurseTimes, ctx);
    if (!isString(ret)) {
      ret = formatValue(ctx, ret, recurseTimes);
    }
    return ret;
  }

  // Primitive types cannot have properties
  var primitive = formatPrimitive(ctx, value);
  if (primitive) {
    return primitive;
  }

  // Look up the keys of the object.
  var keys = Object.keys(value);
  var visibleKeys = arrayToHash(keys);

  if (ctx.showHidden) {
    keys = Object.getOwnPropertyNames(value);
  }

  // IE doesn't make error fields non-enumerable
  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
  if (isError(value)
      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
    return formatError(value);
  }

  // Some type of object without properties can be shortcutted.
  if (keys.length === 0) {
    if (isFunction(value)) {
      var name = value.name ? ': ' + value.name : '';
      return ctx.stylize('[Function' + name + ']', 'special');
    }
    if (isRegExp(value)) {
      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
    }
    if (isDate(value)) {
      return ctx.stylize(Date.prototype.toString.call(value), 'date');
    }
    if (isError(value)) {
      return formatError(value);
    }
  }

  var base = '', array = false, braces = ['{', '}'];

  // Make Array say that they are Array
  if (isArray(value)) {
    array = true;
    braces = ['[', ']'];
  }

  // Make functions say that they are functions
  if (isFunction(value)) {
    var n = value.name ? ': ' + value.name : '';
    base = ' [Function' + n + ']';
  }

  // Make RegExps say that they are RegExps
  if (isRegExp(value)) {
    base = ' ' + RegExp.prototype.toString.call(value);
  }

  // Make dates with properties first say the date
  if (isDate(value)) {
    base = ' ' + Date.prototype.toUTCString.call(value);
  }

  // Make error with message first say the error
  if (isError(value)) {
    base = ' ' + formatError(value);
  }

  if (keys.length === 0 && (!array || value.length == 0)) {
    return braces[0] + base + braces[1];
  }

  if (recurseTimes < 0) {
    if (isRegExp(value)) {
      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
    } else {
      return ctx.stylize('[Object]', 'special');
    }
  }

  ctx.seen.push(value);

  var output;
  if (array) {
    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
  } else {
    output = keys.map(function(key) {
      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
    });
  }

  ctx.seen.pop();

  return reduceToSingleString(output, base, braces);
}


function formatPrimitive(ctx, value) {
  if (isUndefined(value))
    return ctx.stylize('undefined', 'undefined');
  if (isString(value)) {
    var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
                                             .replace(/'/g, "\\'")
                                             .replace(/\\"/g, '"') + '\'';
    return ctx.stylize(simple, 'string');
  }
  if (isNumber(value))
    return ctx.stylize('' + value, 'number');
  if (isBoolean(value))
    return ctx.stylize('' + value, 'boolean');
  // For some reason typeof null is "object", so special case here.
  if (isNull(value))
    return ctx.stylize('null', 'null');
}


function formatError(value) {
  return '[' + Error.prototype.toString.call(value) + ']';
}


function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
  var output = [];
  for (var i = 0, l = value.length; i < l; ++i) {
    if (hasOwnProperty(value, String(i))) {
      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
          String(i), true));
    } else {
      output.push('');
    }
  }
  keys.forEach(function(key) {
    if (!key.match(/^\d+$/)) {
      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
          key, true));
    }
  });
  return output;
}


function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
  var name, str, desc;
  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
  if (desc.get) {
    if (desc.set) {
      str = ctx.stylize('[Getter/Setter]', 'special');
    } else {
      str = ctx.stylize('[Getter]', 'special');
    }
  } else {
    if (desc.set) {
      str = ctx.stylize('[Setter]', 'special');
    }
  }
  if (!hasOwnProperty(visibleKeys, key)) {
    name = '[' + key + ']';
  }
  if (!str) {
    if (ctx.seen.indexOf(desc.value) < 0) {
      if (isNull(recurseTimes)) {
        str = formatValue(ctx, desc.value, null);
      } else {
        str = formatValue(ctx, desc.value, recurseTimes - 1);
      }
      if (str.indexOf('\n') > -1) {
        if (array) {
          str = str.split('\n').map(function(line) {
            return '  ' + line;
          }).join('\n').substr(2);
        } else {
          str = '\n' + str.split('\n').map(function(line) {
            return '   ' + line;
          }).join('\n');
        }
      }
    } else {
      str = ctx.stylize('[Circular]', 'special');
    }
  }
  if (isUndefined(name)) {
    if (array && key.match(/^\d+$/)) {
      return str;
    }
    name = JSON.stringify('' + key);
    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
      name = name.substr(1, name.length - 2);
      name = ctx.stylize(name, 'name');
    } else {
      name = name.replace(/'/g, "\\'")
                 .replace(/\\"/g, '"')
                 .replace(/(^"|"$)/g, "'");
      name = ctx.stylize(name, 'string');
    }
  }

  return name + ': ' + str;
}


function reduceToSingleString(output, base, braces) {
  var numLinesEst = 0;
  var length = output.reduce(function(prev, cur) {
    numLinesEst++;
    if (cur.indexOf('\n') >= 0) numLinesEst++;
    return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
  }, 0);

  if (length > 60) {
    return braces[0] +
           (base === '' ? '' : base + '\n ') +
           ' ' +
           output.join(',\n  ') +
           ' ' +
           braces[1];
  }

  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
}


// NOTE: These type checking functions intentionally don't use `instanceof`
// because it is fragile and can be easily faked with `Object.create()`.
function isArray(ar) {
  return Array.isArray(ar);
}
exports.isArray = isArray;

function isBoolean(arg) {
  return typeof arg === 'boolean';
}
exports.isBoolean = isBoolean;

function isNull(arg) {
  return arg === null;
}
exports.isNull = isNull;

function isNullOrUndefined(arg) {
  return arg == null;
}
exports.isNullOrUndefined = isNullOrUndefined;

function isNumber(arg) {
  return typeof arg === 'number';
}
exports.isNumber = isNumber;

function isString(arg) {
  return typeof arg === 'string';
}
exports.isString = isString;

function isSymbol(arg) {
  return typeof arg === 'symbol';
}
exports.isSymbol = isSymbol;

function isUndefined(arg) {
  return arg === void 0;
}
exports.isUndefined = isUndefined;

function isRegExp(re) {
  return isObject(re) && objectToString(re) === '[object RegExp]';
}
exports.isRegExp = isRegExp;

function isObject(arg) {
  return typeof arg === 'object' && arg !== null;
}
exports.isObject = isObject;

function isDate(d) {
  return isObject(d) && objectToString(d) === '[object Date]';
}
exports.isDate = isDate;

function isError(e) {
  return isObject(e) &&
      (objectToString(e) === '[object Error]' || e instanceof Error);
}
exports.isError = isError;

function isFunction(arg) {
  return typeof arg === 'function';
}
exports.isFunction = isFunction;

function isPrimitive(arg) {
  return arg === null ||
         typeof arg === 'boolean' ||
         typeof arg === 'number' ||
         typeof arg === 'string' ||
         typeof arg === 'symbol' ||  // ES6 symbol
         typeof arg === 'undefined';
}
exports.isPrimitive = isPrimitive;

exports.isBuffer = require('./support/isBuffer');

function objectToString(o) {
  return Object.prototype.toString.call(o);
}


function pad(n) {
  return n < 10 ? '0' + n.toString(10) : n.toString(10);
}


var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
              'Oct', 'Nov', 'Dec'];

// 26 Feb 16:19:34
function timestamp() {
  var d = new Date();
  var time = [pad(d.getHours()),
              pad(d.getMinutes()),
              pad(d.getSeconds())].join(':');
  return [d.getDate(), months[d.getMonth()], time].join(' ');
}


// log is just a thin wrapper to console.log that prepends a timestamp
exports.log = function() {
  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
};


/**
 * Inherit the prototype methods from one constructor into another.
 *
 * The Function.prototype.inherits from lang.js rewritten as a standalone
 * function (not on Function.prototype). NOTE: If this file is to be loaded
 * during bootstrapping this function needs to be rewritten using some native
 * functions as prototype setup using normal JavaScript does not work as
 * expected during bootstrapping (see mirror.js in r114903).
 *
 * @param {function} ctor Constructor function which needs to inherit the
 *     prototype.
 * @param {function} superCtor Constructor function to inherit prototype from.
 */
exports.inherits = require('inherits');

exports._extend = function(origin, add) {
  // Don't do anything if add isn't an object
  if (!add || !isObject(add)) return origin;

  var keys = Object.keys(add);
  var i = keys.length;
  while (i--) {
    origin[keys[i]] = add[keys[i]];
  }
  return origin;
};

function hasOwnProperty(obj, prop) {
  return Object.prototype.hasOwnProperty.call(obj, prop);
}

}).call(this)}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{"./support/isBuffer":75,"_process":714,"inherits":74}],77:[function(require,module,exports){
'use strict'

exports.byteLength = byteLength
exports.toByteArray = toByteArray
exports.fromByteArray = fromByteArray

var lookup = []
var revLookup = []
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array

var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
for (var i = 0, len = code.length; i < len; ++i) {
  lookup[i] = code[i]
  revLookup[code.charCodeAt(i)] = i
}

// Support decoding URL-safe base64 strings, as Node.js does.
// See: https://en.wikipedia.org/wiki/Base64#URL_applications
revLookup['-'.charCodeAt(0)] = 62
revLookup['_'.charCodeAt(0)] = 63

function getLens (b64) {
  var len = b64.length

  if (len % 4 > 0) {
    throw new Error('Invalid string. Length must be a multiple of 4')
  }

  // Trim off extra bytes after placeholder bytes are found
  // See: https://github.com/beatgammit/base64-js/issues/42
  var validLen = b64.indexOf('=')
  if (validLen === -1) validLen = len

  var placeHoldersLen = validLen === len
    ? 0
    : 4 - (validLen % 4)

  return [validLen, placeHoldersLen]
}

// base64 is 4/3 + up to two characters of the original data
function byteLength (b64) {
  var lens = getLens(b64)
  var validLen = lens[0]
  var placeHoldersLen = lens[1]
  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}

function _byteLength (b64, validLen, placeHoldersLen) {
  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}

function toByteArray (b64) {
  var tmp
  var lens = getLens(b64)
  var validLen = lens[0]
  var placeHoldersLen = lens[1]

  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))

  var curByte = 0

  // if there are placeholders, only get up to the last complete 4 chars
  var len = placeHoldersLen > 0
    ? validLen - 4
    : validLen

  var i
  for (i = 0; i < len; i += 4) {
    tmp =
      (revLookup[b64.charCodeAt(i)] << 18) |
      (revLookup[b64.charCodeAt(i + 1)] << 12) |
      (revLookup[b64.charCodeAt(i + 2)] << 6) |
      revLookup[b64.charCodeAt(i + 3)]
    arr[curByte++] = (tmp >> 16) & 0xFF
    arr[curByte++] = (tmp >> 8) & 0xFF
    arr[curByte++] = tmp & 0xFF
  }

  if (placeHoldersLen === 2) {
    tmp =
      (revLookup[b64.charCodeAt(i)] << 2) |
      (revLookup[b64.charCodeAt(i + 1)] >> 4)
    arr[curByte++] = tmp & 0xFF
  }

  if (placeHoldersLen === 1) {
    tmp =
      (revLookup[b64.charCodeAt(i)] << 10) |
      (revLookup[b64.charCodeAt(i + 1)] << 4) |
      (revLookup[b64.charCodeAt(i + 2)] >> 2)
    arr[curByte++] = (tmp >> 8) & 0xFF
    arr[curByte++] = tmp & 0xFF
  }

  return arr
}

function tripletToBase64 (num) {
  return lookup[num >> 18 & 0x3F] +
    lookup[num >> 12 & 0x3F] +
    lookup[num >> 6 & 0x3F] +
    lookup[num & 0x3F]
}

function encodeChunk (uint8, start, end) {
  var tmp
  var output = []
  for (var i = start; i < end; i += 3) {
    tmp =
      ((uint8[i] << 16) & 0xFF0000) +
      ((uint8[i + 1] << 8) & 0xFF00) +
      (uint8[i + 2] & 0xFF)
    output.push(tripletToBase64(tmp))
  }
  return output.join('')
}

function fromByteArray (uint8) {
  var tmp
  var len = uint8.length
  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
  var parts = []
  var maxChunkLength = 16383 // must be multiple of 3

  // go through the array every three bytes, we'll deal with trailing stuff later
  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
  }

  // pad the end with zeros, but make sure to not forget the extra bytes
  if (extraBytes === 1) {
    tmp = uint8[len - 1]
    parts.push(
      lookup[tmp >> 2] +
      lookup[(tmp << 4) & 0x3F] +
      '=='
    )
  } else if (extraBytes === 2) {
    tmp = (uint8[len - 2] << 8) + uint8[len - 1]
    parts.push(
      lookup[tmp >> 10] +
      lookup[(tmp >> 4) & 0x3F] +
      lookup[(tmp << 2) & 0x3F] +
      '='
    )
  }

  return parts.join('')
}

},{}],78:[function(require,module,exports){
var bigInt = (function (undefined) {
    "use strict";

    var BASE = 1e7,
        LOG_BASE = 7,
        MAX_INT = 9007199254740992,
        MAX_INT_ARR = smallToArray(MAX_INT),
        DEFAULT_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";

    var supportsNativeBigInt = typeof BigInt === "function";

    function Integer(v, radix, alphabet, caseSensitive) {
        if (typeof v === "undefined") return Integer[0];
        if (typeof radix !== "undefined") return +radix === 10 && !alphabet ? parseValue(v) : parseBase(v, radix, alphabet, caseSensitive);
        return parseValue(v);
    }

    function BigInteger(value, sign) {
        this.value = value;
        this.sign = sign;
        this.isSmall = false;
    }
    BigInteger.prototype = Object.create(Integer.prototype);

    function SmallInteger(value) {
        this.value = value;
        this.sign = value < 0;
        this.isSmall = true;
    }
    SmallInteger.prototype = Object.create(Integer.prototype);

    function NativeBigInt(value) {
        this.value = value;
    }
    NativeBigInt.prototype = Object.create(Integer.prototype);

    function isPrecise(n) {
        return -MAX_INT < n && n < MAX_INT;
    }

    function smallToArray(n) { // For performance reasons doesn't reference BASE, need to change this function if BASE changes
        if (n < 1e7)
            return [n];
        if (n < 1e14)
            return [n % 1e7, Math.floor(n / 1e7)];
        return [n % 1e7, Math.floor(n / 1e7) % 1e7, Math.floor(n / 1e14)];
    }

    function arrayToSmall(arr) { // If BASE changes this function may need to change
        trim(arr);
        var length = arr.length;
        if (length < 4 && compareAbs(arr, MAX_INT_ARR) < 0) {
            switch (length) {
                case 0: return 0;
                case 1: return arr[0];
                case 2: return arr[0] + arr[1] * BASE;
                default: return arr[0] + (arr[1] + arr[2] * BASE) * BASE;
            }
        }
        return arr;
    }

    function trim(v) {
        var i = v.length;
        while (v[--i] === 0);
        v.length = i + 1;
    }

    function createArray(length) { // function shamelessly stolen from Yaffle's library https://github.com/Yaffle/BigInteger
        var x = new Array(length);
        var i = -1;
        while (++i < length) {
            x[i] = 0;
        }
        return x;
    }

    function truncate(n) {
        if (n > 0) return Math.floor(n);
        return Math.ceil(n);
    }

    function add(a, b) { // assumes a and b are arrays with a.length >= b.length
        var l_a = a.length,
            l_b = b.length,
            r = new Array(l_a),
            carry = 0,
            base = BASE,
            sum, i;
        for (i = 0; i < l_b; i++) {
            sum = a[i] + b[i] + carry;
            carry = sum >= base ? 1 : 0;
            r[i] = sum - carry * base;
        }
        while (i < l_a) {
            sum = a[i] + carry;
            carry = sum === base ? 1 : 0;
            r[i++] = sum - carry * base;
        }
        if (carry > 0) r.push(carry);
        return r;
    }

    function addAny(a, b) {
        if (a.length >= b.length) return add(a, b);
        return add(b, a);
    }

    function addSmall(a, carry) { // assumes a is array, carry is number with 0 <= carry < MAX_INT
        var l = a.length,
            r = new Array(l),
            base = BASE,
            sum, i;
        for (i = 0; i < l; i++) {
            sum = a[i] - base + carry;
            carry = Math.floor(sum / base);
            r[i] = sum - carry * base;
            carry += 1;
        }
        while (carry > 0) {
            r[i++] = carry % base;
            carry = Math.floor(carry / base);
        }
        return r;
    }

    BigInteger.prototype.add = function (v) {
        var n = parseValue(v);
        if (this.sign !== n.sign) {
            return this.subtract(n.negate());
        }
        var a = this.value, b = n.value;
        if (n.isSmall) {
            return new BigInteger(addSmall(a, Math.abs(b)), this.sign);
        }
        return new BigInteger(addAny(a, b), this.sign);
    };
    BigInteger.prototype.plus = BigInteger.prototype.add;

    SmallInteger.prototype.add = function (v) {
        var n = parseValue(v);
        var a = this.value;
        if (a < 0 !== n.sign) {
            return this.subtract(n.negate());
        }
        var b = n.value;
        if (n.isSmall) {
            if (isPrecise(a + b)) return new SmallInteger(a + b);
            b = smallToArray(Math.abs(b));
        }
        return new BigInteger(addSmall(b, Math.abs(a)), a < 0);
    };
    SmallInteger.prototype.plus = SmallInteger.prototype.add;

    NativeBigInt.prototype.add = function (v) {
        return new NativeBigInt(this.value + parseValue(v).value);
    }
    NativeBigInt.prototype.plus = NativeBigInt.prototype.add;

    function subtract(a, b) { // assumes a and b are arrays with a >= b
        var a_l = a.length,
            b_l = b.length,
            r = new Array(a_l),
            borrow = 0,
            base = BASE,
            i, difference;
        for (i = 0; i < b_l; i++) {
            difference = a[i] - borrow - b[i];
            if (difference < 0) {
                difference += base;
                borrow = 1;
            } else borrow = 0;
            r[i] = difference;
        }
        for (i = b_l; i < a_l; i++) {
            difference = a[i] - borrow;
            if (difference < 0) difference += base;
            else {
                r[i++] = difference;
                break;
            }
            r[i] = difference;
        }
        for (; i < a_l; i++) {
            r[i] = a[i];
        }
        trim(r);
        return r;
    }

    function subtractAny(a, b, sign) {
        var value;
        if (compareAbs(a, b) >= 0) {
            value = subtract(a, b);
        } else {
            value = subtract(b, a);
            sign = !sign;
        }
        value = arrayToSmall(value);
        if (typeof value === "number") {
            if (sign) value = -value;
            return new SmallInteger(value);
        }
        return new BigInteger(value, sign);
    }

    function subtractSmall(a, b, sign) { // assumes a is array, b is number with 0 <= b < MAX_INT
        var l = a.length,
            r = new Array(l),
            carry = -b,
            base = BASE,
            i, difference;
        for (i = 0; i < l; i++) {
            difference = a[i] + carry;
            carry = Math.floor(difference / base);
            difference %= base;
            r[i] = difference < 0 ? difference + base : difference;
        }
        r = arrayToSmall(r);
        if (typeof r === "number") {
            if (sign) r = -r;
            return new SmallInteger(r);
        } return new BigInteger(r, sign);
    }

    BigInteger.prototype.subtract = function (v) {
        var n = parseValue(v);
        if (this.sign !== n.sign) {
            return this.add(n.negate());
        }
        var a = this.value, b = n.value;
        if (n.isSmall)
            return subtractSmall(a, Math.abs(b), this.sign);
        return subtractAny(a, b, this.sign);
    };
    BigInteger.prototype.minus = BigInteger.prototype.subtract;

    SmallInteger.prototype.subtract = function (v) {
        var n = parseValue(v);
        var a = this.value;
        if (a < 0 !== n.sign) {
            return this.add(n.negate());
        }
        var b = n.value;
        if (n.isSmall) {
            return new SmallInteger(a - b);
        }
        return subtractSmall(b, Math.abs(a), a >= 0);
    };
    SmallInteger.prototype.minus = SmallInteger.prototype.subtract;

    NativeBigInt.prototype.subtract = function (v) {
        return new NativeBigInt(this.value - parseValue(v).value);
    }
    NativeBigInt.prototype.minus = NativeBigInt.prototype.subtract;

    BigInteger.prototype.negate = function () {
        return new BigInteger(this.value, !this.sign);
    };
    SmallInteger.prototype.negate = function () {
        var sign = this.sign;
        var small = new SmallInteger(-this.value);
        small.sign = !sign;
        return small;
    };
    NativeBigInt.prototype.negate = function () {
        return new NativeBigInt(-this.value);
    }

    BigInteger.prototype.abs = function () {
        return new BigInteger(this.value, false);
    };
    SmallInteger.prototype.abs = function () {
        return new SmallInteger(Math.abs(this.value));
    };
    NativeBigInt.prototype.abs = function () {
        return new NativeBigInt(this.value >= 0 ? this.value : -this.value);
    }


    function multiplyLong(a, b) {
        var a_l = a.length,
            b_l = b.length,
            l = a_l + b_l,
            r = createArray(l),
            base = BASE,
            product, carry, i, a_i, b_j;
        for (i = 0; i < a_l; ++i) {
            a_i = a[i];
            for (var j = 0; j < b_l; ++j) {
                b_j = b[j];
                product = a_i * b_j + r[i + j];
                carry = Math.floor(product / base);
                r[i + j] = product - carry * base;
                r[i + j + 1] += carry;
            }
        }
        trim(r);
        return r;
    }

    function multiplySmall(a, b) { // assumes a is array, b is number with |b| < BASE
        var l = a.length,
            r = new Array(l),
            base = BASE,
            carry = 0,
            product, i;
        for (i = 0; i < l; i++) {
            product = a[i] * b + carry;
            carry = Math.floor(product / base);
            r[i] = product - carry * base;
        }
        while (carry > 0) {
            r[i++] = carry % base;
            carry = Math.floor(carry / base);
        }
        return r;
    }

    function shiftLeft(x, n) {
        var r = [];
        while (n-- > 0) r.push(0);
        return r.concat(x);
    }

    function multiplyKaratsuba(x, y) {
        var n = Math.max(x.length, y.length);

        if (n <= 30) return multiplyLong(x, y);
        n = Math.ceil(n / 2);

        var b = x.slice(n),
            a = x.slice(0, n),
            d = y.slice(n),
            c = y.slice(0, n);

        var ac = multiplyKaratsuba(a, c),
            bd = multiplyKaratsuba(b, d),
            abcd = multiplyKaratsuba(addAny(a, b), addAny(c, d));

        var product = addAny(addAny(ac, shiftLeft(subtract(subtract(abcd, ac), bd), n)), shiftLeft(bd, 2 * n));
        trim(product);
        return product;
    }

    // The following function is derived from a surface fit of a graph plotting the performance difference
    // between long multiplication and karatsuba multiplication versus the lengths of the two arrays.
    function useKaratsuba(l1, l2) {
        return -0.012 * l1 - 0.012 * l2 + 0.000015 * l1 * l2 > 0;
    }

    BigInteger.prototype.multiply = function (v) {
        var n = parseValue(v),
            a = this.value, b = n.value,
            sign = this.sign !== n.sign,
            abs;
        if (n.isSmall) {
            if (b === 0) return Integer[0];
            if (b === 1) return this;
            if (b === -1) return this.negate();
            abs = Math.abs(b);
            if (abs < BASE) {
                return new BigInteger(multiplySmall(a, abs), sign);
            }
            b = smallToArray(abs);
        }
        if (useKaratsuba(a.length, b.length)) // Karatsuba is only faster for certain array sizes
            return new BigInteger(multiplyKaratsuba(a, b), sign);
        return new BigInteger(multiplyLong(a, b), sign);
    };

    BigInteger.prototype.times = BigInteger.prototype.multiply;

    function multiplySmallAndArray(a, b, sign) { // a >= 0
        if (a < BASE) {
            return new BigInteger(multiplySmall(b, a), sign);
        }
        return new BigInteger(multiplyLong(b, smallToArray(a)), sign);
    }
    SmallInteger.prototype._multiplyBySmall = function (a) {
        if (isPrecise(a.value * this.value)) {
            return new SmallInteger(a.value * this.value);
        }
        return multiplySmallAndArray(Math.abs(a.value), smallToArray(Math.abs(this.value)), this.sign !== a.sign);
    };
    BigInteger.prototype._multiplyBySmall = function (a) {
        if (a.value === 0) return Integer[0];
        if (a.value === 1) return this;
        if (a.value === -1) return this.negate();
        return multiplySmallAndArray(Math.abs(a.value), this.value, this.sign !== a.sign);
    };
    SmallInteger.prototype.multiply = function (v) {
        return parseValue(v)._multiplyBySmall(this);
    };
    SmallInteger.prototype.times = SmallInteger.prototype.multiply;

    NativeBigInt.prototype.multiply = function (v) {
        return new NativeBigInt(this.value * parseValue(v).value);
    }
    NativeBigInt.prototype.times = NativeBigInt.prototype.multiply;

    function square(a) {
        //console.assert(2 * BASE * BASE < MAX_INT);
        var l = a.length,
            r = createArray(l + l),
            base = BASE,
            product, carry, i, a_i, a_j;
        for (i = 0; i < l; i++) {
            a_i = a[i];
            carry = 0 - a_i * a_i;
            for (var j = i; j < l; j++) {
                a_j = a[j];
                product = 2 * (a_i * a_j) + r[i + j] + carry;
                carry = Math.floor(product / base);
                r[i + j] = product - carry * base;
            }
            r[i + l] = carry;
        }
        trim(r);
        return r;
    }

    BigInteger.prototype.square = function () {
        return new BigInteger(square(this.value), false);
    };

    SmallInteger.prototype.square = function () {
        var value = this.value * this.value;
        if (isPrecise(value)) return new SmallInteger(value);
        return new BigInteger(square(smallToArray(Math.abs(this.value))), false);
    };

    NativeBigInt.prototype.square = function (v) {
        return new NativeBigInt(this.value * this.value);
    }

    function divMod1(a, b) { // Left over from previous version. Performs faster than divMod2 on smaller input sizes.
        var a_l = a.length,
            b_l = b.length,
            base = BASE,
            result = createArray(b.length),
            divisorMostSignificantDigit = b[b_l - 1],
            // normalization
            lambda = Math.ceil(base / (2 * divisorMostSignificantDigit)),
            remainder = multiplySmall(a, lambda),
            divisor = multiplySmall(b, lambda),
            quotientDigit, shift, carry, borrow, i, l, q;
        if (remainder.length <= a_l) remainder.push(0);
        divisor.push(0);
        divisorMostSignificantDigit = divisor[b_l - 1];
        for (shift = a_l - b_l; shift >= 0; shift--) {
            quotientDigit = base - 1;
            if (remainder[shift + b_l] !== divisorMostSignificantDigit) {
                quotientDigit = Math.floor((remainder[shift + b_l] * base + remainder[shift + b_l - 1]) / divisorMostSignificantDigit);
            }
            // quotientDigit <= base - 1
            carry = 0;
            borrow = 0;
            l = divisor.length;
            for (i = 0; i < l; i++) {
                carry += quotientDigit * divisor[i];
                q = Math.floor(carry / base);
                borrow += remainder[shift + i] - (carry - q * base);
                carry = q;
                if (borrow < 0) {
                    remainder[shift + i] = borrow + base;
                    borrow = -1;
                } else {
                    remainder[shift + i] = borrow;
                    borrow = 0;
                }
            }
            while (borrow !== 0) {
                quotientDigit -= 1;
                carry = 0;
                for (i = 0; i < l; i++) {
                    carry += remainder[shift + i] - base + divisor[i];
                    if (carry < 0) {
                        remainder[shift + i] = carry + base;
                        carry = 0;
                    } else {
                        remainder[shift + i] = carry;
                        carry = 1;
                    }
                }
                borrow += carry;
            }
            result[shift] = quotientDigit;
        }
        // denormalization
        remainder = divModSmall(remainder, lambda)[0];
        return [arrayToSmall(result), arrayToSmall(remainder)];
    }

    function divMod2(a, b) { // Implementation idea shamelessly stolen from Silent Matt's library http://silentmatt.com/biginteger/
        // Performs faster than divMod1 on larger input sizes.
        var a_l = a.length,
            b_l = b.length,
            result = [],
            part = [],
            base = BASE,
            guess, xlen, highx, highy, check;
        while (a_l) {
            part.unshift(a[--a_l]);
            trim(part);
            if (compareAbs(part, b) < 0) {
                result.push(0);
                continue;
            }
            xlen = part.length;
            highx = part[xlen - 1] * base + part[xlen - 2];
            highy = b[b_l - 1] * base + b[b_l - 2];
            if (xlen > b_l) {
                highx = (highx + 1) * base;
            }
            guess = Math.ceil(highx / highy);
            do {
                check = multiplySmall(b, guess);
                if (compareAbs(check, part) <= 0) break;
                guess--;
            } while (guess);
            result.push(guess);
            part = subtract(part, check);
        }
        result.reverse();
        return [arrayToSmall(result), arrayToSmall(part)];
    }

    function divModSmall(value, lambda) {
        var length = value.length,
            quotient = createArray(length),
            base = BASE,
            i, q, remainder, divisor;
        remainder = 0;
        for (i = length - 1; i >= 0; --i) {
            divisor = remainder * base + value[i];
            q = truncate(divisor / lambda);
            remainder = divisor - q * lambda;
            quotient[i] = q | 0;
        }
        return [quotient, remainder | 0];
    }

    function divModAny(self, v) {
        var value, n = parseValue(v);
        if (supportsNativeBigInt) {
            return [new NativeBigInt(self.value / n.value), new NativeBigInt(self.value % n.value)];
        }
        var a = self.value, b = n.value;
        var quotient;
        if (b === 0) throw new Error("Cannot divide by zero");
        if (self.isSmall) {
            if (n.isSmall) {
                return [new SmallInteger(truncate(a / b)), new SmallInteger(a % b)];
            }
            return [Integer[0], self];
        }
        if (n.isSmall) {
            if (b === 1) return [self, Integer[0]];
            if (b == -1) return [self.negate(), Integer[0]];
            var abs = Math.abs(b);
            if (abs < BASE) {
                value = divModSmall(a, abs);
                quotient = arrayToSmall(value[0]);
                var remainder = value[1];
                if (self.sign) remainder = -remainder;
                if (typeof quotient === "number") {
                    if (self.sign !== n.sign) quotient = -quotient;
                    return [new SmallInteger(quotient), new SmallInteger(remainder)];
                }
                return [new BigInteger(quotient, self.sign !== n.sign), new SmallInteger(remainder)];
            }
            b = smallToArray(abs);
        }
        var comparison = compareAbs(a, b);
        if (comparison === -1) return [Integer[0], self];
        if (comparison === 0) return [Integer[self.sign === n.sign ? 1 : -1], Integer[0]];

        // divMod1 is faster on smaller input sizes
        if (a.length + b.length <= 200)
            value = divMod1(a, b);
        else value = divMod2(a, b);

        quotient = value[0];
        var qSign = self.sign !== n.sign,
            mod = value[1],
            mSign = self.sign;
        if (typeof quotient === "number") {
            if (qSign) quotient = -quotient;
            quotient = new SmallInteger(quotient);
        } else quotient = new BigInteger(quotient, qSign);
        if (typeof mod === "number") {
            if (mSign) mod = -mod;
            mod = new SmallInteger(mod);
        } else mod = new BigInteger(mod, mSign);
        return [quotient, mod];
    }

    BigInteger.prototype.divmod = function (v) {
        var result = divModAny(this, v);
        return {
            quotient: result[0],
            remainder: result[1]
        };
    };
    NativeBigInt.prototype.divmod = SmallInteger.prototype.divmod = BigInteger.prototype.divmod;


    BigInteger.prototype.divide = function (v) {
        return divModAny(this, v)[0];
    };
    NativeBigInt.prototype.over = NativeBigInt.prototype.divide = function (v) {
        return new NativeBigInt(this.value / parseValue(v).value);
    };
    SmallInteger.prototype.over = SmallInteger.prototype.divide = BigInteger.prototype.over = BigInteger.prototype.divide;

    BigInteger.prototype.mod = function (v) {
        return divModAny(this, v)[1];
    };
    NativeBigInt.prototype.mod = NativeBigInt.prototype.remainder = function (v) {
        return new NativeBigInt(this.value % parseValue(v).value);
    };
    SmallInteger.prototype.remainder = SmallInteger.prototype.mod = BigInteger.prototype.remainder = BigInteger.prototype.mod;

    BigInteger.prototype.pow = function (v) {
        var n = parseValue(v),
            a = this.value,
            b = n.value,
            value, x, y;
        if (b === 0) return Integer[1];
        if (a === 0) return Integer[0];
        if (a === 1) return Integer[1];
        if (a === -1) return n.isEven() ? Integer[1] : Integer[-1];
        if (n.sign) {
            return Integer[0];
        }
        if (!n.isSmall) throw new Error("The exponent " + n.toString() + " is too large.");
        if (this.isSmall) {
            if (isPrecise(value = Math.pow(a, b)))
                return new SmallInteger(truncate(value));
        }
        x = this;
        y = Integer[1];
        while (true) {
            if (b & 1 === 1) {
                y = y.times(x);
                --b;
            }
            if (b === 0) break;
            b /= 2;
            x = x.square();
        }
        return y;
    };
    SmallInteger.prototype.pow = BigInteger.prototype.pow;

    NativeBigInt.prototype.pow = function (v) {
        var n = parseValue(v);
        var a = this.value, b = n.value;
        var _0 = BigInt(0), _1 = BigInt(1), _2 = BigInt(2);
        if (b === _0) return Integer[1];
        if (a === _0) return Integer[0];
        if (a === _1) return Integer[1];
        if (a === BigInt(-1)) return n.isEven() ? Integer[1] : Integer[-1];
        if (n.isNegative()) return new NativeBigInt(_0);
        var x = this;
        var y = Integer[1];
        while (true) {
            if ((b & _1) === _1) {
                y = y.times(x);
                --b;
            }
            if (b === _0) break;
            b /= _2;
            x = x.square();
        }
        return y;
    }

    BigInteger.prototype.modPow = function (exp, mod) {
        exp = parseValue(exp);
        mod = parseValue(mod);
        if (mod.isZero()) throw new Error("Cannot take modPow with modulus 0");
        var r = Integer[1],
            base = this.mod(mod);
        if (exp.isNegative()) {
            exp = exp.multiply(Integer[-1]);
            base = base.modInv(mod);
        }
        while (exp.isPositive()) {
            if (base.isZero()) return Integer[0];
            if (exp.isOdd()) r = r.multiply(base).mod(mod);
            exp = exp.divide(2);
            base = base.square().mod(mod);
        }
        return r;
    };
    NativeBigInt.prototype.modPow = SmallInteger.prototype.modPow = BigInteger.prototype.modPow;

    function compareAbs(a, b) {
        if (a.length !== b.length) {
            return a.length > b.length ? 1 : -1;
        }
        for (var i = a.length - 1; i >= 0; i--) {
            if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;
        }
        return 0;
    }

    BigInteger.prototype.compareAbs = function (v) {
        var n = parseValue(v),
            a = this.value,
            b = n.value;
        if (n.isSmall) return 1;
        return compareAbs(a, b);
    };
    SmallInteger.prototype.compareAbs = function (v) {
        var n = parseValue(v),
            a = Math.abs(this.value),
            b = n.value;
        if (n.isSmall) {
            b = Math.abs(b);
            return a === b ? 0 : a > b ? 1 : -1;
        }
        return -1;
    };
    NativeBigInt.prototype.compareAbs = function (v) {
        var a = this.value;
        var b = parseValue(v).value;
        a = a >= 0 ? a : -a;
        b = b >= 0 ? b : -b;
        return a === b ? 0 : a > b ? 1 : -1;
    }

    BigInteger.prototype.compare = function (v) {
        // See discussion about comparison with Infinity:
        // https://github.com/peterolson/BigInteger.js/issues/61
        if (v === Infinity) {
            return -1;
        }
        if (v === -Infinity) {
            return 1;
        }

        var n = parseValue(v),
            a = this.value,
            b = n.value;
        if (this.sign !== n.sign) {
            return n.sign ? 1 : -1;
        }
        if (n.isSmall) {
            return this.sign ? -1 : 1;
        }
        return compareAbs(a, b) * (this.sign ? -1 : 1);
    };
    BigInteger.prototype.compareTo = BigInteger.prototype.compare;

    SmallInteger.prototype.compare = function (v) {
        if (v === Infinity) {
            return -1;
        }
        if (v === -Infinity) {
            return 1;
        }

        var n = parseValue(v),
            a = this.value,
            b = n.value;
        if (n.isSmall) {
            return a == b ? 0 : a > b ? 1 : -1;
        }
        if (a < 0 !== n.sign) {
            return a < 0 ? -1 : 1;
        }
        return a < 0 ? 1 : -1;
    };
    SmallInteger.prototype.compareTo = SmallInteger.prototype.compare;

    NativeBigInt.prototype.compare = function (v) {
        if (v === Infinity) {
            return -1;
        }
        if (v === -Infinity) {
            return 1;
        }
        var a = this.value;
        var b = parseValue(v).value;
        return a === b ? 0 : a > b ? 1 : -1;
    }
    NativeBigInt.prototype.compareTo = NativeBigInt.prototype.compare;

    BigInteger.prototype.equals = function (v) {
        return this.compare(v) === 0;
    };
    NativeBigInt.prototype.eq = NativeBigInt.prototype.equals = SmallInteger.prototype.eq = SmallInteger.prototype.equals = BigInteger.prototype.eq = BigInteger.prototype.equals;

    BigInteger.prototype.notEquals = function (v) {
        return this.compare(v) !== 0;
    };
    NativeBigInt.prototype.neq = NativeBigInt.prototype.notEquals = SmallInteger.prototype.neq = SmallInteger.prototype.notEquals = BigInteger.prototype.neq = BigInteger.prototype.notEquals;

    BigInteger.prototype.greater = function (v) {
        return this.compare(v) > 0;
    };
    NativeBigInt.prototype.gt = NativeBigInt.prototype.greater = SmallInteger.prototype.gt = SmallInteger.prototype.greater = BigInteger.prototype.gt = BigInteger.prototype.greater;

    BigInteger.prototype.lesser = function (v) {
        return this.compare(v) < 0;
    };
    NativeBigInt.prototype.lt = NativeBigInt.prototype.lesser = SmallInteger.prototype.lt = SmallInteger.prototype.lesser = BigInteger.prototype.lt = BigInteger.prototype.lesser;

    BigInteger.prototype.greaterOrEquals = function (v) {
        return this.compare(v) >= 0;
    };
    NativeBigInt.prototype.geq = NativeBigInt.prototype.greaterOrEquals = SmallInteger.prototype.geq = SmallInteger.prototype.greaterOrEquals = BigInteger.prototype.geq = BigInteger.prototype.greaterOrEquals;

    BigInteger.prototype.lesserOrEquals = function (v) {
        return this.compare(v) <= 0;
    };
    NativeBigInt.prototype.leq = NativeBigInt.prototype.lesserOrEquals = SmallInteger.prototype.leq = SmallInteger.prototype.lesserOrEquals = BigInteger.prototype.leq = BigInteger.prototype.lesserOrEquals;

    BigInteger.prototype.isEven = function () {
        return (this.value[0] & 1) === 0;
    };
    SmallInteger.prototype.isEven = function () {
        return (this.value & 1) === 0;
    };
    NativeBigInt.prototype.isEven = function () {
        return (this.value & BigInt(1)) === BigInt(0);
    }

    BigInteger.prototype.isOdd = function () {
        return (this.value[0] & 1) === 1;
    };
    SmallInteger.prototype.isOdd = function () {
        return (this.value & 1) === 1;
    };
    NativeBigInt.prototype.isOdd = function () {
        return (this.value & BigInt(1)) === BigInt(1);
    }

    BigInteger.prototype.isPositive = function () {
        return !this.sign;
    };
    SmallInteger.prototype.isPositive = function () {
        return this.value > 0;
    };
    NativeBigInt.prototype.isPositive = SmallInteger.prototype.isPositive;

    BigInteger.prototype.isNegative = function () {
        return this.sign;
    };
    SmallInteger.prototype.isNegative = function () {
        return this.value < 0;
    };
    NativeBigInt.prototype.isNegative = SmallInteger.prototype.isNegative;

    BigInteger.prototype.isUnit = function () {
        return false;
    };
    SmallInteger.prototype.isUnit = function () {
        return Math.abs(this.value) === 1;
    };
    NativeBigInt.prototype.isUnit = function () {
        return this.abs().value === BigInt(1);
    }

    BigInteger.prototype.isZero = function () {
        return false;
    };
    SmallInteger.prototype.isZero = function () {
        return this.value === 0;
    };
    NativeBigInt.prototype.isZero = function () {
        return this.value === BigInt(0);
    }

    BigInteger.prototype.isDivisibleBy = function (v) {
        var n = parseValue(v);
        if (n.isZero()) return false;
        if (n.isUnit()) return true;
        if (n.compareAbs(2) === 0) return this.isEven();
        return this.mod(n).isZero();
    };
    NativeBigInt.prototype.isDivisibleBy = SmallInteger.prototype.isDivisibleBy = BigInteger.prototype.isDivisibleBy;

    function isBasicPrime(v) {
        var n = v.abs();
        if (n.isUnit()) return false;
        if (n.equals(2) || n.equals(3) || n.equals(5)) return true;
        if (n.isEven() || n.isDivisibleBy(3) || n.isDivisibleBy(5)) return false;
        if (n.lesser(49)) return true;
        // we don't know if it's prime: let the other functions figure it out
    }

    function millerRabinTest(n, a) {
        var nPrev = n.prev(),
            b = nPrev,
            r = 0,
            d, t, i, x;
        while (b.isEven()) b = b.divide(2), r++;
        next: for (i = 0; i < a.length; i++) {
            if (n.lesser(a[i])) continue;
            x = bigInt(a[i]).modPow(b, n);
            if (x.isUnit() || x.equals(nPrev)) continue;
            for (d = r - 1; d != 0; d--) {
                x = x.square().mod(n);
                if (x.isUnit()) return false;
                if (x.equals(nPrev)) continue next;
            }
            return false;
        }
        return true;
    }

    // Set "strict" to true to force GRH-supported lower bound of 2*log(N)^2
    BigInteger.prototype.isPrime = function (strict) {
        var isPrime = isBasicPrime(this);
        if (isPrime !== undefined) return isPrime;
        var n = this.abs();
        var bits = n.bitLength();
        if (bits <= 64)
            return millerRabinTest(n, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]);
        var logN = Math.log(2) * bits.toJSNumber();
        var t = Math.ceil((strict === true) ? (2 * Math.pow(logN, 2)) : logN);
        for (var a = [], i = 0; i < t; i++) {
            a.push(bigInt(i + 2));
        }
        return millerRabinTest(n, a);
    };
    NativeBigInt.prototype.isPrime = SmallInteger.prototype.isPrime = BigInteger.prototype.isPrime;

    BigInteger.prototype.isProbablePrime = function (iterations, rng) {
        var isPrime = isBasicPrime(this);
        if (isPrime !== undefined) return isPrime;
        var n = this.abs();
        var t = iterations === undefined ? 5 : iterations;
        for (var a = [], i = 0; i < t; i++) {
            a.push(bigInt.randBetween(2, n.minus(2), rng));
        }
        return millerRabinTest(n, a);
    };
    NativeBigInt.prototype.isProbablePrime = SmallInteger.prototype.isProbablePrime = BigInteger.prototype.isProbablePrime;

    BigInteger.prototype.modInv = function (n) {
        var t = bigInt.zero, newT = bigInt.one, r = parseValue(n), newR = this.abs(), q, lastT, lastR;
        while (!newR.isZero()) {
            q = r.divide(newR);
            lastT = t;
            lastR = r;
            t = newT;
            r = newR;
            newT = lastT.subtract(q.multiply(newT));
            newR = lastR.subtract(q.multiply(newR));
        }
        if (!r.isUnit()) throw new Error(this.toString() + " and " + n.toString() + " are not co-prime");
        if (t.compare(0) === -1) {
            t = t.add(n);
        }
        if (this.isNegative()) {
            return t.negate();
        }
        return t;
    };

    NativeBigInt.prototype.modInv = SmallInteger.prototype.modInv = BigInteger.prototype.modInv;

    BigInteger.prototype.next = function () {
        var value = this.value;
        if (this.sign) {
            return subtractSmall(value, 1, this.sign);
        }
        return new BigInteger(addSmall(value, 1), this.sign);
    };
    SmallInteger.prototype.next = function () {
        var value = this.value;
        if (value + 1 < MAX_INT) return new SmallInteger(value + 1);
        return new BigInteger(MAX_INT_ARR, false);
    };
    NativeBigInt.prototype.next = function () {
        return new NativeBigInt(this.value + BigInt(1));
    }

    BigInteger.prototype.prev = function () {
        var value = this.value;
        if (this.sign) {
            return new BigInteger(addSmall(value, 1), true);
        }
        return subtractSmall(value, 1, this.sign);
    };
    SmallInteger.prototype.prev = function () {
        var value = this.value;
        if (value - 1 > -MAX_INT) return new SmallInteger(value - 1);
        return new BigInteger(MAX_INT_ARR, true);
    };
    NativeBigInt.prototype.prev = function () {
        return new NativeBigInt(this.value - BigInt(1));
    }

    var powersOfTwo = [1];
    while (2 * powersOfTwo[powersOfTwo.length - 1] <= BASE) powersOfTwo.push(2 * powersOfTwo[powersOfTwo.length - 1]);
    var powers2Length = powersOfTwo.length, highestPower2 = powersOfTwo[powers2Length - 1];

    function shift_isSmall(n) {
        return Math.abs(n) <= BASE;
    }

    BigInteger.prototype.shiftLeft = function (v) {
        var n = parseValue(v).toJSNumber();
        if (!shift_isSmall(n)) {
            throw new Error(String(n) + " is too large for shifting.");
        }
        if (n < 0) return this.shiftRight(-n);
        var result = this;
        if (result.isZero()) return result;
        while (n >= powers2Length) {
            result = result.multiply(highestPower2);
            n -= powers2Length - 1;
        }
        return result.multiply(powersOfTwo[n]);
    };
    NativeBigInt.prototype.shiftLeft = SmallInteger.prototype.shiftLeft = BigInteger.prototype.shiftLeft;

    BigInteger.prototype.shiftRight = function (v) {
        var remQuo;
        var n = parseValue(v).toJSNumber();
        if (!shift_isSmall(n)) {
            throw new Error(String(n) + " is too large for shifting.");
        }
        if (n < 0) return this.shiftLeft(-n);
        var result = this;
        while (n >= powers2Length) {
            if (result.isZero() || (result.isNegative() && result.isUnit())) return result;
            remQuo = divModAny(result, highestPower2);
            result = remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];
            n -= powers2Length - 1;
        }
        remQuo = divModAny(result, powersOfTwo[n]);
        return remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];
    };
    NativeBigInt.prototype.shiftRight = SmallInteger.prototype.shiftRight = BigInteger.prototype.shiftRight;

    function bitwise(x, y, fn) {
        y = parseValue(y);
        var xSign = x.isNegative(), ySign = y.isNegative();
        var xRem = xSign ? x.not() : x,
            yRem = ySign ? y.not() : y;
        var xDigit = 0, yDigit = 0;
        var xDivMod = null, yDivMod = null;
        var result = [];
        while (!xRem.isZero() || !yRem.isZero()) {
            xDivMod = divModAny(xRem, highestPower2);
            xDigit = xDivMod[1].toJSNumber();
            if (xSign) {
                xDigit = highestPower2 - 1 - xDigit; // two's complement for negative numbers
            }

            yDivMod = divModAny(yRem, highestPower2);
            yDigit = yDivMod[1].toJSNumber();
            if (ySign) {
                yDigit = highestPower2 - 1 - yDigit; // two's complement for negative numbers
            }

            xRem = xDivMod[0];
            yRem = yDivMod[0];
            result.push(fn(xDigit, yDigit));
        }
        var sum = fn(xSign ? 1 : 0, ySign ? 1 : 0) !== 0 ? bigInt(-1) : bigInt(0);
        for (var i = result.length - 1; i >= 0; i -= 1) {
            sum = sum.multiply(highestPower2).add(bigInt(result[i]));
        }
        return sum;
    }

    BigInteger.prototype.not = function () {
        return this.negate().prev();
    };
    NativeBigInt.prototype.not = SmallInteger.prototype.not = BigInteger.prototype.not;

    BigInteger.prototype.and = function (n) {
        return bitwise(this, n, function (a, b) { return a & b; });
    };
    NativeBigInt.prototype.and = SmallInteger.prototype.and = BigInteger.prototype.and;

    BigInteger.prototype.or = function (n) {
        return bitwise(this, n, function (a, b) { return a | b; });
    };
    NativeBigInt.prototype.or = SmallInteger.prototype.or = BigInteger.prototype.or;

    BigInteger.prototype.xor = function (n) {
        return bitwise(this, n, function (a, b) { return a ^ b; });
    };
    NativeBigInt.prototype.xor = SmallInteger.prototype.xor = BigInteger.prototype.xor;

    var LOBMASK_I = 1 << 30, LOBMASK_BI = (BASE & -BASE) * (BASE & -BASE) | LOBMASK_I;
    function roughLOB(n) { // get lowestOneBit (rough)
        // SmallInteger: return Min(lowestOneBit(n), 1 << 30)
        // BigInteger: return Min(lowestOneBit(n), 1 << 14) [BASE=1e7]
        var v = n.value,
            x = typeof v === "number" ? v | LOBMASK_I :
                typeof v === "bigint" ? v | BigInt(LOBMASK_I) :
                    v[0] + v[1] * BASE | LOBMASK_BI;
        return x & -x;
    }

    function integerLogarithm(value, base) {
        if (base.compareTo(value) <= 0) {
            var tmp = integerLogarithm(value, base.square(base));
            var p = tmp.p;
            var e = tmp.e;
            var t = p.multiply(base);
            return t.compareTo(value) <= 0 ? { p: t, e: e * 2 + 1 } : { p: p, e: e * 2 };
        }
        return { p: bigInt(1), e: 0 };
    }

    BigInteger.prototype.bitLength = function () {
        var n = this;
        if (n.compareTo(bigInt(0)) < 0) {
            n = n.negate().subtract(bigInt(1));
        }
        if (n.compareTo(bigInt(0)) === 0) {
            return bigInt(0);
        }
        return bigInt(integerLogarithm(n, bigInt(2)).e).add(bigInt(1));
    }
    NativeBigInt.prototype.bitLength = SmallInteger.prototype.bitLength = BigInteger.prototype.bitLength;

    function max(a, b) {
        a = parseValue(a);
        b = parseValue(b);
        return a.greater(b) ? a : b;
    }
    function min(a, b) {
        a = parseValue(a);
        b = parseValue(b);
        return a.lesser(b) ? a : b;
    }
    function gcd(a, b) {
        a = parseValue(a).abs();
        b = parseValue(b).abs();
        if (a.equals(b)) return a;
        if (a.isZero()) return b;
        if (b.isZero()) return a;
        var c = Integer[1], d, t;
        while (a.isEven() && b.isEven()) {
            d = min(roughLOB(a), roughLOB(b));
            a = a.divide(d);
            b = b.divide(d);
            c = c.multiply(d);
        }
        while (a.isEven()) {
            a = a.divide(roughLOB(a));
        }
        do {
            while (b.isEven()) {
                b = b.divide(roughLOB(b));
            }
            if (a.greater(b)) {
                t = b; b = a; a = t;
            }
            b = b.subtract(a);
        } while (!b.isZero());
        return c.isUnit() ? a : a.multiply(c);
    }
    function lcm(a, b) {
        a = parseValue(a).abs();
        b = parseValue(b).abs();
        return a.divide(gcd(a, b)).multiply(b);
    }
    function randBetween(a, b, rng) {
        a = parseValue(a);
        b = parseValue(b);
        var usedRNG = rng || Math.random;
        var low = min(a, b), high = max(a, b);
        var range = high.subtract(low).add(1);
        if (range.isSmall) return low.add(Math.floor(usedRNG() * range));
        var digits = toBase(range, BASE).value;
        var result = [], restricted = true;
        for (var i = 0; i < digits.length; i++) {
            var top = restricted ? digits[i] + (i + 1 < digits.length ? digits[i + 1] / BASE : 0) : BASE;
            var digit = truncate(usedRNG() * top);
            result.push(digit);
            if (digit < digits[i]) restricted = false;
        }
        return low.add(Integer.fromArray(result, BASE, false));
    }

    var parseBase = function (text, base, alphabet, caseSensitive) {
        alphabet = alphabet || DEFAULT_ALPHABET;
        text = String(text);
        if (!caseSensitive) {
            text = text.toLowerCase();
            alphabet = alphabet.toLowerCase();
        }
        var length = text.length;
        var i;
        var absBase = Math.abs(base);
        var alphabetValues = {};
        for (i = 0; i < alphabet.length; i++) {
            alphabetValues[alphabet[i]] = i;
        }
        for (i = 0; i < length; i++) {
            var c = text[i];
            if (c === "-") continue;
            if (c in alphabetValues) {
                if (alphabetValues[c] >= absBase) {
                    if (c === "1" && absBase === 1) continue;
                    throw new Error(c + " is not a valid digit in base " + base + ".");
                }
            }
        }
        base = parseValue(base);
        var digits = [];
        var isNegative = text[0] === "-";
        for (i = isNegative ? 1 : 0; i < text.length; i++) {
            var c = text[i];
            if (c in alphabetValues) digits.push(parseValue(alphabetValues[c]));
            else if (c === "<") {
                var start = i;
                do { i++; } while (text[i] !== ">" && i < text.length);
                digits.push(parseValue(text.slice(start + 1, i)));
            }
            else throw new Error(c + " is not a valid character");
        }
        return parseBaseFromArray(digits, base, isNegative);
    };

    function parseBaseFromArray(digits, base, isNegative) {
        var val = Integer[0], pow = Integer[1], i;
        for (i = digits.length - 1; i >= 0; i--) {
            val = val.add(digits[i].times(pow));
            pow = pow.times(base);
        }
        return isNegative ? val.negate() : val;
    }

    function stringify(digit, alphabet) {
        alphabet = alphabet || DEFAULT_ALPHABET;
        if (digit < alphabet.length) {
            return alphabet[digit];
        }
        return "<" + digit + ">";
    }

    function toBase(n, base) {
        base = bigInt(base);
        if (base.isZero()) {
            if (n.isZero()) return { value: [0], isNegative: false };
            throw new Error("Cannot convert nonzero numbers to base 0.");
        }
        if (base.equals(-1)) {
            if (n.isZero()) return { value: [0], isNegative: false };
            if (n.isNegative())
                return {
                    value: [].concat.apply([], Array.apply(null, Array(-n.toJSNumber()))
                        .map(Array.prototype.valueOf, [1, 0])
                    ),
                    isNegative: false
                };

            var arr = Array.apply(null, Array(n.toJSNumber() - 1))
                .map(Array.prototype.valueOf, [0, 1]);
            arr.unshift([1]);
            return {
                value: [].concat.apply([], arr),
                isNegative: false
            };
        }

        var neg = false;
        if (n.isNegative() && base.isPositive()) {
            neg = true;
            n = n.abs();
        }
        if (base.isUnit()) {
            if (n.isZero()) return { value: [0], isNegative: false };

            return {
                value: Array.apply(null, Array(n.toJSNumber()))
                    .map(Number.prototype.valueOf, 1),
                isNegative: neg
            };
        }
        var out = [];
        var left = n, divmod;
        while (left.isNegative() || left.compareAbs(base) >= 0) {
            divmod = left.divmod(base);
            left = divmod.quotient;
            var digit = divmod.remainder;
            if (digit.isNegative()) {
                digit = base.minus(digit).abs();
                left = left.next();
            }
            out.push(digit.toJSNumber());
        }
        out.push(left.toJSNumber());
        return { value: out.reverse(), isNegative: neg };
    }

    function toBaseString(n, base, alphabet) {
        var arr = toBase(n, base);
        return (arr.isNegative ? "-" : "") + arr.value.map(function (x) {
            return stringify(x, alphabet);
        }).join('');
    }

    BigInteger.prototype.toArray = function (radix) {
        return toBase(this, radix);
    };

    SmallInteger.prototype.toArray = function (radix) {
        return toBase(this, radix);
    };

    NativeBigInt.prototype.toArray = function (radix) {
        return toBase(this, radix);
    };

    BigInteger.prototype.toString = function (radix, alphabet) {
        if (radix === undefined) radix = 10;
        if (radix !== 10) return toBaseString(this, radix, alphabet);
        var v = this.value, l = v.length, str = String(v[--l]), zeros = "0000000", digit;
        while (--l >= 0) {
            digit = String(v[l]);
            str += zeros.slice(digit.length) + digit;
        }
        var sign = this.sign ? "-" : "";
        return sign + str;
    };

    SmallInteger.prototype.toString = function (radix, alphabet) {
        if (radix === undefined) radix = 10;
        if (radix != 10) return toBaseString(this, radix, alphabet);
        return String(this.value);
    };

    NativeBigInt.prototype.toString = SmallInteger.prototype.toString;

    NativeBigInt.prototype.toJSON = BigInteger.prototype.toJSON = SmallInteger.prototype.toJSON = function () { return this.toString(); }

    BigInteger.prototype.valueOf = function () {
        return parseInt(this.toString(), 10);
    };
    BigInteger.prototype.toJSNumber = BigInteger.prototype.valueOf;

    SmallInteger.prototype.valueOf = function () {
        return this.value;
    };
    SmallInteger.prototype.toJSNumber = SmallInteger.prototype.valueOf;
    NativeBigInt.prototype.valueOf = NativeBigInt.prototype.toJSNumber = function () {
        return parseInt(this.toString(), 10);
    }

    function parseStringValue(v) {
        if (isPrecise(+v)) {
            var x = +v;
            if (x === truncate(x))
                return supportsNativeBigInt ? new NativeBigInt(BigInt(x)) : new SmallInteger(x);
            throw new Error("Invalid integer: " + v);
        }
        var sign = v[0] === "-";
        if (sign) v = v.slice(1);
        var split = v.split(/e/i);
        if (split.length > 2) throw new Error("Invalid integer: " + split.join("e"));
        if (split.length === 2) {
            var exp = split[1];
            if (exp[0] === "+") exp = exp.slice(1);
            exp = +exp;
            if (exp !== truncate(exp) || !isPrecise(exp)) throw new Error("Invalid integer: " + exp + " is not a valid exponent.");
            var text = split[0];
            var decimalPlace = text.indexOf(".");
            if (decimalPlace >= 0) {
                exp -= text.length - decimalPlace - 1;
                text = text.slice(0, decimalPlace) + text.slice(decimalPlace + 1);
            }
            if (exp < 0) throw new Error("Cannot include negative exponent part for integers");
            text += (new Array(exp + 1)).join("0");
            v = text;
        }
        var isValid = /^([0-9][0-9]*)$/.test(v);
        if (!isValid) throw new Error("Invalid integer: " + v);
        if (supportsNativeBigInt) {
            return new NativeBigInt(BigInt(sign ? "-" + v : v));
        }
        var r = [], max = v.length, l = LOG_BASE, min = max - l;
        while (max > 0) {
            r.push(+v.slice(min, max));
            min -= l;
            if (min < 0) min = 0;
            max -= l;
        }
        trim(r);
        return new BigInteger(r, sign);
    }

    function parseNumberValue(v) {
        if (supportsNativeBigInt) {
            return new NativeBigInt(BigInt(v));
        }
        if (isPrecise(v)) {
            if (v !== truncate(v)) throw new Error(v + " is not an integer.");
            return new SmallInteger(v);
        }
        return parseStringValue(v.toString());
    }

    function parseValue(v) {
        if (typeof v === "number") {
            return parseNumberValue(v);
        }
        if (typeof v === "string") {
            return parseStringValue(v);
        }
        if (typeof v === "bigint") {
            return new NativeBigInt(v);
        }
        return v;
    }
    // Pre-define numbers in range [-999,999]
    for (var i = 0; i < 1000; i++) {
        Integer[i] = parseValue(i);
        if (i > 0) Integer[-i] = parseValue(-i);
    }
    // Backwards compatibility
    Integer.one = Integer[1];
    Integer.zero = Integer[0];
    Integer.minusOne = Integer[-1];
    Integer.max = max;
    Integer.min = min;
    Integer.gcd = gcd;
    Integer.lcm = lcm;
    Integer.isInstance = function (x) { return x instanceof BigInteger || x instanceof SmallInteger || x instanceof NativeBigInt; };
    Integer.randBetween = randBetween;

    Integer.fromArray = function (digits, base, isNegative) {
        return parseBaseFromArray(digits.map(parseValue), parseValue(base || 10), isNegative);
    };

    return Integer;
})();

// Node.js check
if (typeof module !== "undefined" && module.hasOwnProperty("exports")) {
    module.exports = bigInt;
}

//amd check
if (typeof define === "function" && define.amd) {
    define( function () {
        return bigInt;
    });
}

},{}],79:[function(require,module,exports){
(function (Buffer){(function (){
(function (root) {

/**********************************************************
 *
 * BitView
 *
 * BitView provides a similar interface to the standard
 * DataView, but with support for bit-level reads / writes.
 *
 **********************************************************/
var BitView = function (source, byteOffset, byteLength) {
	var isBuffer = source instanceof ArrayBuffer ||
		(typeof Buffer !== 'undefined' && source instanceof Buffer);

	if (!isBuffer) {
		throw new Error('Must specify a valid ArrayBuffer or Buffer.');
	}

	byteOffset = byteOffset || 0;
	byteLength = byteLength || source.byteLength /* ArrayBuffer */ || source.length /* Buffer */;

	this._buffer = source;
	this._view = new Uint8Array(this._buffer, byteOffset, byteLength);
};

// Used to massage fp values so we can operate on them
// at the bit level.
BitView._scratch = new DataView(new ArrayBuffer(8));

Object.defineProperty(BitView.prototype, 'buffer', {
	get: function () { return this._buffer; },
	enumerable: true,
	configurable: false
});

Object.defineProperty(BitView.prototype, 'byteLength', {
	get: function () { return this._view.length; },
	enumerable: true,
	configurable: false
});

BitView.prototype._getBit = function (offset) {
	return this._view[offset >> 3] >> (offset & 7) & 0x1;
};

BitView.prototype._setBit = function (offset, on) {
	if (on) {
		this._view[offset >> 3] |= 1 << (offset & 7);
	} else {
		this._view[offset >> 3] &= ~(1 << (offset & 7));
	}
};

BitView.prototype.getBits = function (offset, bits, signed) {
	var available = (this._view.length * 8 - offset);

	if (bits > available) {
		throw new Error('Cannot get ' + bits + ' bit(s) from offset ' + offset + ', ' + available + ' available');
	}

	var value = 0;
	for (var i = 0; i < bits;) {
		var read;

		// Read an entire byte if we can.
		if ((bits - i) >= 8 && ((offset & 7) === 0)) {
			value |= (this._view[offset >> 3] << i);
			read = 8;
		} else {
			value |= (this._getBit(offset) << i);
			read = 1;
		}

		offset += read;
		i += read;
	}

	if (signed) {
		// If we're not working with a full 32 bits, check the
		// imaginary MSB for this bit count and convert to a
		// valid 32-bit signed value if set.
		if (bits !== 32 && value & (1 << (bits - 1))) {
			value |= -1 ^ ((1 << bits) - 1);
		}

		return value;
	}

	return value >>> 0;
};

BitView.prototype.setBits = function (offset, value, bits) {
	var available = (this._view.length * 8 - offset);

	if (bits > available) {
		throw new Error('Cannot set ' + bits + ' bit(s) from offset ' + offset + ', ' + available + ' available');
	}

	for (var i = 0; i < bits;) {
		var wrote;

		// Write an entire byte if we can.
		if ((bits - i) >= 8 && ((offset & 7) === 0)) {
			this._view[offset >> 3] = value & 0xFF;
			wrote = 8;
		} else {
			this._setBit(offset, value & 0x1);
			wrote = 1;
		}

		value = (value >> wrote);

		offset += wrote;
		i += wrote;
	}
};

BitView.prototype.getInt8 = function (offset) {
	return this.getBits(offset, 8, true);
};
BitView.prototype.getUint8 = function (offset) {
	return this.getBits(offset, 8, false);
};
BitView.prototype.getInt16 = function (offset) {
	return this.getBits(offset, 16, true);
};
BitView.prototype.getUint16 = function (offset) {
	return this.getBits(offset, 16, false);
};
BitView.prototype.getInt32 = function (offset) {
	return this.getBits(offset, 32, true);
};
BitView.prototype.getUint32 = function (offset) {
	return this.getBits(offset, 32, false);
};
BitView.prototype.getFloat32 = function (offset) {
	BitView._scratch.setUint32(0, this.getUint32(offset));
	return BitView._scratch.getFloat32(0);
};
BitView.prototype.getFloat64 = function (offset) {
	BitView._scratch.setUint32(0, this.getUint32(offset));
	// DataView offset is in bytes.
	BitView._scratch.setUint32(4, this.getUint32(offset+32));
	return BitView._scratch.getFloat64(0);
};

BitView.prototype.setInt8  =
BitView.prototype.setUint8 = function (offset, value) {
	this.setBits(offset, value, 8);
};
BitView.prototype.setInt16  =
BitView.prototype.setUint16 = function (offset, value) {
	this.setBits(offset, value, 16);
};
BitView.prototype.setInt32  =
BitView.prototype.setUint32 = function (offset, value) {
	this.setBits(offset, value, 32);
};
BitView.prototype.setFloat32 = function (offset, value) {
	BitView._scratch.setFloat32(0, value);
	this.setBits(offset, BitView._scratch.getUint32(0), 32);
};
BitView.prototype.setFloat64 = function (offset, value) {
	BitView._scratch.setFloat64(0, value);
	this.setBits(offset, BitView._scratch.getUint32(0), 32);
	this.setBits(offset+32, BitView._scratch.getUint32(4), 32);
};

/**********************************************************
 *
 * BitStream
 *
 * Small wrapper for a BitView to maintain your position,
 * as well as to handle reading / writing of string data
 * to the underlying buffer.
 *
 **********************************************************/
var reader = function (name, size) {
	return function () {
		var val = this._view[name](this._index);
		this._index += size;
		return val;
	};
};

var writer = function (name, size) {
	return function (value) {
		this._view[name](this._index, value);
		this._index += size;
	};
};

function readASCIIString(stream, bytes) {
	var i = 0;
	var chars = [];
	var append = true;

	// Read while we still have space available, or until we've
	// hit the fixed byte length passed in.
	while (!bytes || (bytes && i < bytes)) {
		var c = stream.readUint8();

		// Stop appending chars once we hit 0x00
		if (c === 0x00) {
			append = false;

			// If we don't have a fixed length to read, break out now.
			if (!bytes) {
				break;
			}
		}

		if (append) {
			chars.push(c);
		}

		i++;
	}

	// Convert char code array back to string.
	return chars.map(function (x) {
		return String.fromCharCode(x);
	}).join('');
}

function writeASCIIString(stream, string, bytes) {
	var length = bytes || string.length + 1;  // + 1 for NULL

	for (var i = 0; i < length; i++) {
		stream.writeUint8(i < string.length ? string.charCodeAt(i) : 0x00);
	}
}

var BitStream = function (source, byteOffset, byteLength) {
	var isBuffer = source instanceof ArrayBuffer ||
		(typeof Buffer !== 'undefined' && source instanceof Buffer);

	if (!(source instanceof BitView) && !isBuffer) {
		throw new Error('Must specify a valid BitView, ArrayBuffer or Buffer');
	}

	if (isBuffer) {
		this._view = new BitView(source, byteOffset, byteLength);
	} else {
		this._view = source;
	}

	this._index = 0;
};

Object.defineProperty(BitStream.prototype, 'byteIndex', {
	// Ceil the returned value, over compensating for the amount of
	// bits written to the stream.
	get: function () { return Math.ceil(this._index / 8); },
	set: function (val) { this._index = val * 8; },
	enumerable: true,
	configurable: true
});

Object.defineProperty(BitStream.prototype, 'buffer', {
	get: function () { return this._view.buffer; },
	enumerable: true,
	configurable: false
});

Object.defineProperty(BitStream.prototype, 'view', {
	get: function () { return this._view; },
	enumerable: true,
	configurable: false
});

BitStream.prototype.readBits = function (bits, signed) {
	var val = this._view.getBits(this._index, bits, signed);
	this._index += bits;
	return val;
};

BitStream.prototype.writeBits = function (value, bits) {
	this._view.setBits(this._index, value, bits);
	this._index += bits;
};

BitStream.prototype.readInt8 = reader('getInt8', 8);
BitStream.prototype.readUint8 = reader('getUint8', 8);
BitStream.prototype.readInt16 = reader('getInt16', 16);
BitStream.prototype.readUint16 = reader('getUint16', 16);
BitStream.prototype.readInt32 = reader('getInt32', 32);
BitStream.prototype.readUint32 = reader('getUint32', 32);
BitStream.prototype.readFloat32 = reader('getFloat32', 32);
BitStream.prototype.readFloat64 = reader('getFloat64', 64);

BitStream.prototype.writeInt8 = writer('setInt8', 8);
BitStream.prototype.writeUint8 = writer('setUint8', 8);
BitStream.prototype.writeInt16 = writer('setInt16', 16);
BitStream.prototype.writeUint16 = writer('setUint16', 16);
BitStream.prototype.writeInt32 = writer('setInt32', 32);
BitStream.prototype.writeUint32 = writer('setUint32', 32);
BitStream.prototype.writeFloat32 = writer('setFloat32', 32);
BitStream.prototype.writeFloat64 = writer('setFloat64', 64);

BitStream.prototype.readASCIIString = function (bytes) {
	return readASCIIString(this, bytes);
};

BitStream.prototype.writeASCIIString = function (string, bytes) {
	writeASCIIString(this, string, bytes);
};

// AMD / RequireJS
if (typeof define !== 'undefined' && define.amd) {
	define(function () {
		return {
			BitView: BitView,
			BitStream: BitStream
		};
	});
}
// Node.js
else if (typeof module !== 'undefined' && module.exports) {
	module.exports = {
		BitView: BitView,
		BitStream: BitStream
	};
}

}(this));
}).call(this)}).call(this,require("buffer").Buffer)

},{"buffer":81}],80:[function(require,module,exports){

},{}],81:[function(require,module,exports){
(function (Buffer){(function (){
/*!
 * The buffer module from node.js, for the browser.
 *
 * @author   Feross Aboukhadijeh <https://feross.org>
 * @license  MIT
 */
/* eslint-disable no-proto */

'use strict'

var base64 = require('base64-js')
var ieee754 = require('ieee754')

exports.Buffer = Buffer
exports.SlowBuffer = SlowBuffer
exports.INSPECT_MAX_BYTES = 50

var K_MAX_LENGTH = 0x7fffffff
exports.kMaxLength = K_MAX_LENGTH

/**
 * If `Buffer.TYPED_ARRAY_SUPPORT`:
 *   === true    Use Uint8Array implementation (fastest)
 *   === false   Print warning and recommend using `buffer` v4.x which has an Object
 *               implementation (most compatible, even IE6)
 *
 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
 * Opera 11.6+, iOS 4.2+.
 *
 * We report that the browser does not support typed arrays if the are not subclassable
 * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
 * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
 * for __proto__ and has a buggy typed array implementation.
 */
Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()

if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
    typeof console.error === 'function') {
  console.error(
    'This browser lacks typed array (Uint8Array) support which is required by ' +
    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
  )
}

function typedArraySupport () {
  // Can typed array instances can be augmented?
  try {
    var arr = new Uint8Array(1)
    arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } }
    return arr.foo() === 42
  } catch (e) {
    return false
  }
}

Object.defineProperty(Buffer.prototype, 'parent', {
  enumerable: true,
  get: function () {
    if (!Buffer.isBuffer(this)) return undefined
    return this.buffer
  }
})

Object.defineProperty(Buffer.prototype, 'offset', {
  enumerable: true,
  get: function () {
    if (!Buffer.isBuffer(this)) return undefined
    return this.byteOffset
  }
})

function createBuffer (length) {
  if (length > K_MAX_LENGTH) {
    throw new RangeError('The value "' + length + '" is invalid for option "size"')
  }
  // Return an augmented `Uint8Array` instance
  var buf = new Uint8Array(length)
  buf.__proto__ = Buffer.prototype
  return buf
}

/**
 * The Buffer constructor returns instances of `Uint8Array` that have their
 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
 * and the `Uint8Array` methods. Square bracket notation works as expected -- it
 * returns a single octet.
 *
 * The `Uint8Array` prototype remains unmodified.
 */

function Buffer (arg, encodingOrOffset, length) {
  // Common case.
  if (typeof arg === 'number') {
    if (typeof encodingOrOffset === 'string') {
      throw new TypeError(
        'The "string" argument must be of type string. Received type number'
      )
    }
    return allocUnsafe(arg)
  }
  return from(arg, encodingOrOffset, length)
}

// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
if (typeof Symbol !== 'undefined' && Symbol.species != null &&
    Buffer[Symbol.species] === Buffer) {
  Object.defineProperty(Buffer, Symbol.species, {
    value: null,
    configurable: true,
    enumerable: false,
    writable: false
  })
}

Buffer.poolSize = 8192 // not used by this implementation

function from (value, encodingOrOffset, length) {
  if (typeof value === 'string') {
    return fromString(value, encodingOrOffset)
  }

  if (ArrayBuffer.isView(value)) {
    return fromArrayLike(value)
  }

  if (value == null) {
    throw TypeError(
      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
      'or Array-like Object. Received type ' + (typeof value)
    )
  }

  if (isInstance(value, ArrayBuffer) ||
      (value && isInstance(value.buffer, ArrayBuffer))) {
    return fromArrayBuffer(value, encodingOrOffset, length)
  }

  if (typeof value === 'number') {
    throw new TypeError(
      'The "value" argument must not be of type number. Received type number'
    )
  }

  var valueOf = value.valueOf && value.valueOf()
  if (valueOf != null && valueOf !== value) {
    return Buffer.from(valueOf, encodingOrOffset, length)
  }

  var b = fromObject(value)
  if (b) return b

  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
      typeof value[Symbol.toPrimitive] === 'function') {
    return Buffer.from(
      value[Symbol.toPrimitive]('string'), encodingOrOffset, length
    )
  }

  throw new TypeError(
    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
    'or Array-like Object. Received type ' + (typeof value)
  )
}

/**
 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
 * if value is a number.
 * Buffer.from(str[, encoding])
 * Buffer.from(array)
 * Buffer.from(buffer)
 * Buffer.from(arrayBuffer[, byteOffset[, length]])
 **/
Buffer.from = function (value, encodingOrOffset, length) {
  return from(value, encodingOrOffset, length)
}

// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
// https://github.com/feross/buffer/pull/148
Buffer.prototype.__proto__ = Uint8Array.prototype
Buffer.__proto__ = Uint8Array

function assertSize (size) {
  if (typeof size !== 'number') {
    throw new TypeError('"size" argument must be of type number')
  } else if (size < 0) {
    throw new RangeError('The value "' + size + '" is invalid for option "size"')
  }
}

function alloc (size, fill, encoding) {
  assertSize(size)
  if (size <= 0) {
    return createBuffer(size)
  }
  if (fill !== undefined) {
    // Only pay attention to encoding if it's a string. This
    // prevents accidentally sending in a number that would
    // be interpretted as a start offset.
    return typeof encoding === 'string'
      ? createBuffer(size).fill(fill, encoding)
      : createBuffer(size).fill(fill)
  }
  return createBuffer(size)
}

/**
 * Creates a new filled Buffer instance.
 * alloc(size[, fill[, encoding]])
 **/
Buffer.alloc = function (size, fill, encoding) {
  return alloc(size, fill, encoding)
}

function allocUnsafe (size) {
  assertSize(size)
  return createBuffer(size < 0 ? 0 : checked(size) | 0)
}

/**
 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
 * */
Buffer.allocUnsafe = function (size) {
  return allocUnsafe(size)
}
/**
 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
 */
Buffer.allocUnsafeSlow = function (size) {
  return allocUnsafe(size)
}

function fromString (string, encoding) {
  if (typeof encoding !== 'string' || encoding === '') {
    encoding = 'utf8'
  }

  if (!Buffer.isEncoding(encoding)) {
    throw new TypeError('Unknown encoding: ' + encoding)
  }

  var length = byteLength(string, encoding) | 0
  var buf = createBuffer(length)

  var actual = buf.write(string, encoding)

  if (actual !== length) {
    // Writing a hex string, for example, that contains invalid characters will
    // cause everything after the first invalid character to be ignored. (e.g.
    // 'abxxcd' will be treated as 'ab')
    buf = buf.slice(0, actual)
  }

  return buf
}

function fromArrayLike (array) {
  var length = array.length < 0 ? 0 : checked(array.length) | 0
  var buf = createBuffer(length)
  for (var i = 0; i < length; i += 1) {
    buf[i] = array[i] & 255
  }
  return buf
}

function fromArrayBuffer (array, byteOffset, length) {
  if (byteOffset < 0 || array.byteLength < byteOffset) {
    throw new RangeError('"offset" is outside of buffer bounds')
  }

  if (array.byteLength < byteOffset + (length || 0)) {
    throw new RangeError('"length" is outside of buffer bounds')
  }

  var buf
  if (byteOffset === undefined && length === undefined) {
    buf = new Uint8Array(array)
  } else if (length === undefined) {
    buf = new Uint8Array(array, byteOffset)
  } else {
    buf = new Uint8Array(array, byteOffset, length)
  }

  // Return an augmented `Uint8Array` instance
  buf.__proto__ = Buffer.prototype
  return buf
}

function fromObject (obj) {
  if (Buffer.isBuffer(obj)) {
    var len = checked(obj.length) | 0
    var buf = createBuffer(len)

    if (buf.length === 0) {
      return buf
    }

    obj.copy(buf, 0, 0, len)
    return buf
  }

  if (obj.length !== undefined) {
    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
      return createBuffer(0)
    }
    return fromArrayLike(obj)
  }

  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
    return fromArrayLike(obj.data)
  }
}

function checked (length) {
  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
  // length is NaN (which is otherwise coerced to zero.)
  if (length >= K_MAX_LENGTH) {
    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
                         'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
  }
  return length | 0
}

function SlowBuffer (length) {
  if (+length != length) { // eslint-disable-line eqeqeq
    length = 0
  }
  return Buffer.alloc(+length)
}

Buffer.isBuffer = function isBuffer (b) {
  return b != null && b._isBuffer === true &&
    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
}

Buffer.compare = function compare (a, b) {
  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
    throw new TypeError(
      'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
    )
  }

  if (a === b) return 0

  var x = a.length
  var y = b.length

  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
    if (a[i] !== b[i]) {
      x = a[i]
      y = b[i]
      break
    }
  }

  if (x < y) return -1
  if (y < x) return 1
  return 0
}

Buffer.isEncoding = function isEncoding (encoding) {
  switch (String(encoding).toLowerCase()) {
    case 'hex':
    case 'utf8':
    case 'utf-8':
    case 'ascii':
    case 'latin1':
    case 'binary':
    case 'base64':
    case 'ucs2':
    case 'ucs-2':
    case 'utf16le':
    case 'utf-16le':
      return true
    default:
      return false
  }
}

Buffer.concat = function concat (list, length) {
  if (!Array.isArray(list)) {
    throw new TypeError('"list" argument must be an Array of Buffers')
  }

  if (list.length === 0) {
    return Buffer.alloc(0)
  }

  var i
  if (length === undefined) {
    length = 0
    for (i = 0; i < list.length; ++i) {
      length += list[i].length
    }
  }

  var buffer = Buffer.allocUnsafe(length)
  var pos = 0
  for (i = 0; i < list.length; ++i) {
    var buf = list[i]
    if (isInstance(buf, Uint8Array)) {
      buf = Buffer.from(buf)
    }
    if (!Buffer.isBuffer(buf)) {
      throw new TypeError('"list" argument must be an Array of Buffers')
    }
    buf.copy(buffer, pos)
    pos += buf.length
  }
  return buffer
}

function byteLength (string, encoding) {
  if (Buffer.isBuffer(string)) {
    return string.length
  }
  if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
    return string.byteLength
  }
  if (typeof string !== 'string') {
    throw new TypeError(
      'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
      'Received type ' + typeof string
    )
  }

  var len = string.length
  var mustMatch = (arguments.length > 2 && arguments[2] === true)
  if (!mustMatch && len === 0) return 0

  // Use a for loop to avoid recursion
  var loweredCase = false
  for (;;) {
    switch (encoding) {
      case 'ascii':
      case 'latin1':
      case 'binary':
        return len
      case 'utf8':
      case 'utf-8':
        return utf8ToBytes(string).length
      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return len * 2
      case 'hex':
        return len >>> 1
      case 'base64':
        return base64ToBytes(string).length
      default:
        if (loweredCase) {
          return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8
        }
        encoding = ('' + encoding).toLowerCase()
        loweredCase = true
    }
  }
}
Buffer.byteLength = byteLength

function slowToString (encoding, start, end) {
  var loweredCase = false

  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
  // property of a typed array.

  // This behaves neither like String nor Uint8Array in that we set start/end
  // to their upper/lower bounds if the value passed is out of range.
  // undefined is handled specially as per ECMA-262 6th Edition,
  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
  if (start === undefined || start < 0) {
    start = 0
  }
  // Return early if start > this.length. Done here to prevent potential uint32
  // coercion fail below.
  if (start > this.length) {
    return ''
  }

  if (end === undefined || end > this.length) {
    end = this.length
  }

  if (end <= 0) {
    return ''
  }

  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
  end >>>= 0
  start >>>= 0

  if (end <= start) {
    return ''
  }

  if (!encoding) encoding = 'utf8'

  while (true) {
    switch (encoding) {
      case 'hex':
        return hexSlice(this, start, end)

      case 'utf8':
      case 'utf-8':
        return utf8Slice(this, start, end)

      case 'ascii':
        return asciiSlice(this, start, end)

      case 'latin1':
      case 'binary':
        return latin1Slice(this, start, end)

      case 'base64':
        return base64Slice(this, start, end)

      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return utf16leSlice(this, start, end)

      default:
        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
        encoding = (encoding + '').toLowerCase()
        loweredCase = true
    }
  }
}

// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
// to detect a Buffer instance. It's not possible to use `instanceof Buffer`
// reliably in a browserify context because there could be multiple different
// copies of the 'buffer' package in use. This method works even for Buffer
// instances that were created from another copy of the `buffer` package.
// See: https://github.com/feross/buffer/issues/154
Buffer.prototype._isBuffer = true

function swap (b, n, m) {
  var i = b[n]
  b[n] = b[m]
  b[m] = i
}

Buffer.prototype.swap16 = function swap16 () {
  var len = this.length
  if (len % 2 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 16-bits')
  }
  for (var i = 0; i < len; i += 2) {
    swap(this, i, i + 1)
  }
  return this
}

Buffer.prototype.swap32 = function swap32 () {
  var len = this.length
  if (len % 4 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 32-bits')
  }
  for (var i = 0; i < len; i += 4) {
    swap(this, i, i + 3)
    swap(this, i + 1, i + 2)
  }
  return this
}

Buffer.prototype.swap64 = function swap64 () {
  var len = this.length
  if (len % 8 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 64-bits')
  }
  for (var i = 0; i < len; i += 8) {
    swap(this, i, i + 7)
    swap(this, i + 1, i + 6)
    swap(this, i + 2, i + 5)
    swap(this, i + 3, i + 4)
  }
  return this
}

Buffer.prototype.toString = function toString () {
  var length = this.length
  if (length === 0) return ''
  if (arguments.length === 0) return utf8Slice(this, 0, length)
  return slowToString.apply(this, arguments)
}

Buffer.prototype.toLocaleString = Buffer.prototype.toString

Buffer.prototype.equals = function equals (b) {
  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
  if (this === b) return true
  return Buffer.compare(this, b) === 0
}

Buffer.prototype.inspect = function inspect () {
  var str = ''
  var max = exports.INSPECT_MAX_BYTES
  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
  if (this.length > max) str += ' ... '
  return '<Buffer ' + str + '>'
}

Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
  if (isInstance(target, Uint8Array)) {
    target = Buffer.from(target, target.offset, target.byteLength)
  }
  if (!Buffer.isBuffer(target)) {
    throw new TypeError(
      'The "target" argument must be one of type Buffer or Uint8Array. ' +
      'Received type ' + (typeof target)
    )
  }

  if (start === undefined) {
    start = 0
  }
  if (end === undefined) {
    end = target ? target.length : 0
  }
  if (thisStart === undefined) {
    thisStart = 0
  }
  if (thisEnd === undefined) {
    thisEnd = this.length
  }

  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
    throw new RangeError('out of range index')
  }

  if (thisStart >= thisEnd && start >= end) {
    return 0
  }
  if (thisStart >= thisEnd) {
    return -1
  }
  if (start >= end) {
    return 1
  }

  start >>>= 0
  end >>>= 0
  thisStart >>>= 0
  thisEnd >>>= 0

  if (this === target) return 0

  var x = thisEnd - thisStart
  var y = end - start
  var len = Math.min(x, y)

  var thisCopy = this.slice(thisStart, thisEnd)
  var targetCopy = target.slice(start, end)

  for (var i = 0; i < len; ++i) {
    if (thisCopy[i] !== targetCopy[i]) {
      x = thisCopy[i]
      y = targetCopy[i]
      break
    }
  }

  if (x < y) return -1
  if (y < x) return 1
  return 0
}

// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
//
// Arguments:
// - buffer - a Buffer to search
// - val - a string, Buffer, or number
// - byteOffset - an index into `buffer`; will be clamped to an int32
// - encoding - an optional encoding, relevant is val is a string
// - dir - true for indexOf, false for lastIndexOf
function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
  // Empty buffer means no match
  if (buffer.length === 0) return -1

  // Normalize byteOffset
  if (typeof byteOffset === 'string') {
    encoding = byteOffset
    byteOffset = 0
  } else if (byteOffset > 0x7fffffff) {
    byteOffset = 0x7fffffff
  } else if (byteOffset < -0x80000000) {
    byteOffset = -0x80000000
  }
  byteOffset = +byteOffset // Coerce to Number.
  if (numberIsNaN(byteOffset)) {
    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
    byteOffset = dir ? 0 : (buffer.length - 1)
  }

  // Normalize byteOffset: negative offsets start from the end of the buffer
  if (byteOffset < 0) byteOffset = buffer.length + byteOffset
  if (byteOffset >= buffer.length) {
    if (dir) return -1
    else byteOffset = buffer.length - 1
  } else if (byteOffset < 0) {
    if (dir) byteOffset = 0
    else return -1
  }

  // Normalize val
  if (typeof val === 'string') {
    val = Buffer.from(val, encoding)
  }

  // Finally, search either indexOf (if dir is true) or lastIndexOf
  if (Buffer.isBuffer(val)) {
    // Special case: looking for empty string/buffer always fails
    if (val.length === 0) {
      return -1
    }
    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
  } else if (typeof val === 'number') {
    val = val & 0xFF // Search for a byte value [0-255]
    if (typeof Uint8Array.prototype.indexOf === 'function') {
      if (dir) {
        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
      } else {
        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
      }
    }
    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
  }

  throw new TypeError('val must be string, number or Buffer')
}

function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
  var indexSize = 1
  var arrLength = arr.length
  var valLength = val.length

  if (encoding !== undefined) {
    encoding = String(encoding).toLowerCase()
    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
        encoding === 'utf16le' || encoding === 'utf-16le') {
      if (arr.length < 2 || val.length < 2) {
        return -1
      }
      indexSize = 2
      arrLength /= 2
      valLength /= 2
      byteOffset /= 2
    }
  }

  function read (buf, i) {
    if (indexSize === 1) {
      return buf[i]
    } else {
      return buf.readUInt16BE(i * indexSize)
    }
  }

  var i
  if (dir) {
    var foundIndex = -1
    for (i = byteOffset; i < arrLength; i++) {
      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
        if (foundIndex === -1) foundIndex = i
        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
      } else {
        if (foundIndex !== -1) i -= i - foundIndex
        foundIndex = -1
      }
    }
  } else {
    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
    for (i = byteOffset; i >= 0; i--) {
      var found = true
      for (var j = 0; j < valLength; j++) {
        if (read(arr, i + j) !== read(val, j)) {
          found = false
          break
        }
      }
      if (found) return i
    }
  }

  return -1
}

Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
  return this.indexOf(val, byteOffset, encoding) !== -1
}

Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
}

Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
}

function hexWrite (buf, string, offset, length) {
  offset = Number(offset) || 0
  var remaining = buf.length - offset
  if (!length) {
    length = remaining
  } else {
    length = Number(length)
    if (length > remaining) {
      length = remaining
    }
  }

  var strLen = string.length

  if (length > strLen / 2) {
    length = strLen / 2
  }
  for (var i = 0; i < length; ++i) {
    var parsed = parseInt(string.substr(i * 2, 2), 16)
    if (numberIsNaN(parsed)) return i
    buf[offset + i] = parsed
  }
  return i
}

function utf8Write (buf, string, offset, length) {
  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
}

function asciiWrite (buf, string, offset, length) {
  return blitBuffer(asciiToBytes(string), buf, offset, length)
}

function latin1Write (buf, string, offset, length) {
  return asciiWrite(buf, string, offset, length)
}

function base64Write (buf, string, offset, length) {
  return blitBuffer(base64ToBytes(string), buf, offset, length)
}

function ucs2Write (buf, string, offset, length) {
  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
}

Buffer.prototype.write = function write (string, offset, length, encoding) {
  // Buffer#write(string)
  if (offset === undefined) {
    encoding = 'utf8'
    length = this.length
    offset = 0
  // Buffer#write(string, encoding)
  } else if (length === undefined && typeof offset === 'string') {
    encoding = offset
    length = this.length
    offset = 0
  // Buffer#write(string, offset[, length][, encoding])
  } else if (isFinite(offset)) {
    offset = offset >>> 0
    if (isFinite(length)) {
      length = length >>> 0
      if (encoding === undefined) encoding = 'utf8'
    } else {
      encoding = length
      length = undefined
    }
  } else {
    throw new Error(
      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
    )
  }

  var remaining = this.length - offset
  if (length === undefined || length > remaining) length = remaining

  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
    throw new RangeError('Attempt to write outside buffer bounds')
  }

  if (!encoding) encoding = 'utf8'

  var loweredCase = false
  for (;;) {
    switch (encoding) {
      case 'hex':
        return hexWrite(this, string, offset, length)

      case 'utf8':
      case 'utf-8':
        return utf8Write(this, string, offset, length)

      case 'ascii':
        return asciiWrite(this, string, offset, length)

      case 'latin1':
      case 'binary':
        return latin1Write(this, string, offset, length)

      case 'base64':
        // Warning: maxLength not taken into account in base64Write
        return base64Write(this, string, offset, length)

      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return ucs2Write(this, string, offset, length)

      default:
        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
        encoding = ('' + encoding).toLowerCase()
        loweredCase = true
    }
  }
}

Buffer.prototype.toJSON = function toJSON () {
  return {
    type: 'Buffer',
    data: Array.prototype.slice.call(this._arr || this, 0)
  }
}

function base64Slice (buf, start, end) {
  if (start === 0 && end === buf.length) {
    return base64.fromByteArray(buf)
  } else {
    return base64.fromByteArray(buf.slice(start, end))
  }
}

function utf8Slice (buf, start, end) {
  end = Math.min(buf.length, end)
  var res = []

  var i = start
  while (i < end) {
    var firstByte = buf[i]
    var codePoint = null
    var bytesPerSequence = (firstByte > 0xEF) ? 4
      : (firstByte > 0xDF) ? 3
        : (firstByte > 0xBF) ? 2
          : 1

    if (i + bytesPerSequence <= end) {
      var secondByte, thirdByte, fourthByte, tempCodePoint

      switch (bytesPerSequence) {
        case 1:
          if (firstByte < 0x80) {
            codePoint = firstByte
          }
          break
        case 2:
          secondByte = buf[i + 1]
          if ((secondByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
            if (tempCodePoint > 0x7F) {
              codePoint = tempCodePoint
            }
          }
          break
        case 3:
          secondByte = buf[i + 1]
          thirdByte = buf[i + 2]
          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
              codePoint = tempCodePoint
            }
          }
          break
        case 4:
          secondByte = buf[i + 1]
          thirdByte = buf[i + 2]
          fourthByte = buf[i + 3]
          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
              codePoint = tempCodePoint
            }
          }
      }
    }

    if (codePoint === null) {
      // we did not generate a valid codePoint so insert a
      // replacement char (U+FFFD) and advance only 1 byte
      codePoint = 0xFFFD
      bytesPerSequence = 1
    } else if (codePoint > 0xFFFF) {
      // encode to utf16 (surrogate pair dance)
      codePoint -= 0x10000
      res.push(codePoint >>> 10 & 0x3FF | 0xD800)
      codePoint = 0xDC00 | codePoint & 0x3FF
    }

    res.push(codePoint)
    i += bytesPerSequence
  }

  return decodeCodePointsArray(res)
}

// Based on http://stackoverflow.com/a/22747272/680742, the browser with
// the lowest limit is Chrome, with 0x10000 args.
// We go 1 magnitude less, for safety
var MAX_ARGUMENTS_LENGTH = 0x1000

function decodeCodePointsArray (codePoints) {
  var len = codePoints.length
  if (len <= MAX_ARGUMENTS_LENGTH) {
    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
  }

  // Decode in chunks to avoid "call stack size exceeded".
  var res = ''
  var i = 0
  while (i < len) {
    res += String.fromCharCode.apply(
      String,
      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
    )
  }
  return res
}

function asciiSlice (buf, start, end) {
  var ret = ''
  end = Math.min(buf.length, end)

  for (var i = start; i < end; ++i) {
    ret += String.fromCharCode(buf[i] & 0x7F)
  }
  return ret
}

function latin1Slice (buf, start, end) {
  var ret = ''
  end = Math.min(buf.length, end)

  for (var i = start; i < end; ++i) {
    ret += String.fromCharCode(buf[i])
  }
  return ret
}

function hexSlice (buf, start, end) {
  var len = buf.length

  if (!start || start < 0) start = 0
  if (!end || end < 0 || end > len) end = len

  var out = ''
  for (var i = start; i < end; ++i) {
    out += toHex(buf[i])
  }
  return out
}

function utf16leSlice (buf, start, end) {
  var bytes = buf.slice(start, end)
  var res = ''
  for (var i = 0; i < bytes.length; i += 2) {
    res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
  }
  return res
}

Buffer.prototype.slice = function slice (start, end) {
  var len = this.length
  start = ~~start
  end = end === undefined ? len : ~~end

  if (start < 0) {
    start += len
    if (start < 0) start = 0
  } else if (start > len) {
    start = len
  }

  if (end < 0) {
    end += len
    if (end < 0) end = 0
  } else if (end > len) {
    end = len
  }

  if (end < start) end = start

  var newBuf = this.subarray(start, end)
  // Return an augmented `Uint8Array` instance
  newBuf.__proto__ = Buffer.prototype
  return newBuf
}

/*
 * Need to make sure that buffer isn't trying to write out of bounds.
 */
function checkOffset (offset, ext, length) {
  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
}

Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

  var val = this[offset]
  var mul = 1
  var i = 0
  while (++i < byteLength && (mul *= 0x100)) {
    val += this[offset + i] * mul
  }

  return val
}

Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) {
    checkOffset(offset, byteLength, this.length)
  }

  var val = this[offset + --byteLength]
  var mul = 1
  while (byteLength > 0 && (mul *= 0x100)) {
    val += this[offset + --byteLength] * mul
  }

  return val
}

Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 1, this.length)
  return this[offset]
}

Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 2, this.length)
  return this[offset] | (this[offset + 1] << 8)
}

Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 2, this.length)
  return (this[offset] << 8) | this[offset + 1]
}

Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)

  return ((this[offset]) |
      (this[offset + 1] << 8) |
      (this[offset + 2] << 16)) +
      (this[offset + 3] * 0x1000000)
}

Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)

  return (this[offset] * 0x1000000) +
    ((this[offset + 1] << 16) |
    (this[offset + 2] << 8) |
    this[offset + 3])
}

Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

  var val = this[offset]
  var mul = 1
  var i = 0
  while (++i < byteLength && (mul *= 0x100)) {
    val += this[offset + i] * mul
  }
  mul *= 0x80

  if (val >= mul) val -= Math.pow(2, 8 * byteLength)

  return val
}

Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

  var i = byteLength
  var mul = 1
  var val = this[offset + --i]
  while (i > 0 && (mul *= 0x100)) {
    val += this[offset + --i] * mul
  }
  mul *= 0x80

  if (val >= mul) val -= Math.pow(2, 8 * byteLength)

  return val
}

Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 1, this.length)
  if (!(this[offset] & 0x80)) return (this[offset])
  return ((0xff - this[offset] + 1) * -1)
}

Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 2, this.length)
  var val = this[offset] | (this[offset + 1] << 8)
  return (val & 0x8000) ? val | 0xFFFF0000 : val
}

Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 2, this.length)
  var val = this[offset + 1] | (this[offset] << 8)
  return (val & 0x8000) ? val | 0xFFFF0000 : val
}

Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)

  return (this[offset]) |
    (this[offset + 1] << 8) |
    (this[offset + 2] << 16) |
    (this[offset + 3] << 24)
}

Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)

  return (this[offset] << 24) |
    (this[offset + 1] << 16) |
    (this[offset + 2] << 8) |
    (this[offset + 3])
}

Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)
  return ieee754.read(this, offset, true, 23, 4)
}

Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 4, this.length)
  return ieee754.read(this, offset, false, 23, 4)
}

Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 8, this.length)
  return ieee754.read(this, offset, true, 52, 8)
}

Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
  offset = offset >>> 0
  if (!noAssert) checkOffset(offset, 8, this.length)
  return ieee754.read(this, offset, false, 52, 8)
}

function checkInt (buf, value, offset, ext, max, min) {
  if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
  if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
  if (offset + ext > buf.length) throw new RangeError('Index out of range')
}

Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) {
    var maxBytes = Math.pow(2, 8 * byteLength) - 1
    checkInt(this, value, offset, byteLength, maxBytes, 0)
  }

  var mul = 1
  var i = 0
  this[offset] = value & 0xFF
  while (++i < byteLength && (mul *= 0x100)) {
    this[offset + i] = (value / mul) & 0xFF
  }

  return offset + byteLength
}

Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset >>> 0
  byteLength = byteLength >>> 0
  if (!noAssert) {
    var maxBytes = Math.pow(2, 8 * byteLength) - 1
    checkInt(this, value, offset, byteLength, maxBytes, 0)
  }

  var i = byteLength - 1
  var mul = 1
  this[offset + i] = value & 0xFF
  while (--i >= 0 && (mul *= 0x100)) {
    this[offset + i] = (value / mul) & 0xFF
  }

  return offset + byteLength
}

Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
  this[offset] = (value & 0xff)
  return offset + 1
}

Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
  this[offset] = (value & 0xff)
  this[offset + 1] = (value >>> 8)
  return offset + 2
}

Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
  this[offset] = (value >>> 8)
  this[offset + 1] = (value & 0xff)
  return offset + 2
}

Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
  this[offset + 3] = (value >>> 24)
  this[offset + 2] = (value >>> 16)
  this[offset + 1] = (value >>> 8)
  this[offset] = (value & 0xff)
  return offset + 4
}

Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
  this[offset] = (value >>> 24)
  this[offset + 1] = (value >>> 16)
  this[offset + 2] = (value >>> 8)
  this[offset + 3] = (value & 0xff)
  return offset + 4
}

Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) {
    var limit = Math.pow(2, (8 * byteLength) - 1)

    checkInt(this, value, offset, byteLength, limit - 1, -limit)
  }

  var i = 0
  var mul = 1
  var sub = 0
  this[offset] = value & 0xFF
  while (++i < byteLength && (mul *= 0x100)) {
    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
      sub = 1
    }
    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
  }

  return offset + byteLength
}

Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) {
    var limit = Math.pow(2, (8 * byteLength) - 1)

    checkInt(this, value, offset, byteLength, limit - 1, -limit)
  }

  var i = byteLength - 1
  var mul = 1
  var sub = 0
  this[offset + i] = value & 0xFF
  while (--i >= 0 && (mul *= 0x100)) {
    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
      sub = 1
    }
    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
  }

  return offset + byteLength
}

Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
  if (value < 0) value = 0xff + value + 1
  this[offset] = (value & 0xff)
  return offset + 1
}

Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
  this[offset] = (value & 0xff)
  this[offset + 1] = (value >>> 8)
  return offset + 2
}

Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
  this[offset] = (value >>> 8)
  this[offset + 1] = (value & 0xff)
  return offset + 2
}

Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
  this[offset] = (value & 0xff)
  this[offset + 1] = (value >>> 8)
  this[offset + 2] = (value >>> 16)
  this[offset + 3] = (value >>> 24)
  return offset + 4
}

Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
  if (value < 0) value = 0xffffffff + value + 1
  this[offset] = (value >>> 24)
  this[offset + 1] = (value >>> 16)
  this[offset + 2] = (value >>> 8)
  this[offset + 3] = (value & 0xff)
  return offset + 4
}

function checkIEEE754 (buf, value, offset, ext, max, min) {
  if (offset + ext > buf.length) throw new RangeError('Index out of range')
  if (offset < 0) throw new RangeError('Index out of range')
}

function writeFloat (buf, value, offset, littleEndian, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) {
    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
  }
  ieee754.write(buf, value, offset, littleEndian, 23, 4)
  return offset + 4
}

Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
  return writeFloat(this, value, offset, true, noAssert)
}

Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
  return writeFloat(this, value, offset, false, noAssert)
}

function writeDouble (buf, value, offset, littleEndian, noAssert) {
  value = +value
  offset = offset >>> 0
  if (!noAssert) {
    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
  }
  ieee754.write(buf, value, offset, littleEndian, 52, 8)
  return offset + 8
}

Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
  return writeDouble(this, value, offset, true, noAssert)
}

Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
  return writeDouble(this, value, offset, false, noAssert)
}

// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
  if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
  if (!start) start = 0
  if (!end && end !== 0) end = this.length
  if (targetStart >= target.length) targetStart = target.length
  if (!targetStart) targetStart = 0
  if (end > 0 && end < start) end = start

  // Copy 0 bytes; we're done
  if (end === start) return 0
  if (target.length === 0 || this.length === 0) return 0

  // Fatal error conditions
  if (targetStart < 0) {
    throw new RangeError('targetStart out of bounds')
  }
  if (start < 0 || start >= this.length) throw new RangeError('Index out of range')
  if (end < 0) throw new RangeError('sourceEnd out of bounds')

  // Are we oob?
  if (end > this.length) end = this.length
  if (target.length - targetStart < end - start) {
    end = target.length - targetStart + start
  }

  var len = end - start

  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
    // Use built-in when available, missing from IE11
    this.copyWithin(targetStart, start, end)
  } else if (this === target && start < targetStart && targetStart < end) {
    // descending copy from end
    for (var i = len - 1; i >= 0; --i) {
      target[i + targetStart] = this[i + start]
    }
  } else {
    Uint8Array.prototype.set.call(
      target,
      this.subarray(start, end),
      targetStart
    )
  }

  return len
}

// Usage:
//    buffer.fill(number[, offset[, end]])
//    buffer.fill(buffer[, offset[, end]])
//    buffer.fill(string[, offset[, end]][, encoding])
Buffer.prototype.fill = function fill (val, start, end, encoding) {
  // Handle string cases:
  if (typeof val === 'string') {
    if (typeof start === 'string') {
      encoding = start
      start = 0
      end = this.length
    } else if (typeof end === 'string') {
      encoding = end
      end = this.length
    }
    if (encoding !== undefined && typeof encoding !== 'string') {
      throw new TypeError('encoding must be a string')
    }
    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
      throw new TypeError('Unknown encoding: ' + encoding)
    }
    if (val.length === 1) {
      var code = val.charCodeAt(0)
      if ((encoding === 'utf8' && code < 128) ||
          encoding === 'latin1') {
        // Fast path: If `val` fits into a single byte, use that numeric value.
        val = code
      }
    }
  } else if (typeof val === 'number') {
    val = val & 255
  }

  // Invalid ranges are not set to a default, so can range check early.
  if (start < 0 || this.length < start || this.length < end) {
    throw new RangeError('Out of range index')
  }

  if (end <= start) {
    return this
  }

  start = start >>> 0
  end = end === undefined ? this.length : end >>> 0

  if (!val) val = 0

  var i
  if (typeof val === 'number') {
    for (i = start; i < end; ++i) {
      this[i] = val
    }
  } else {
    var bytes = Buffer.isBuffer(val)
      ? val
      : Buffer.from(val, encoding)
    var len = bytes.length
    if (len === 0) {
      throw new TypeError('The value "' + val +
        '" is invalid for argument "value"')
    }
    for (i = 0; i < end - start; ++i) {
      this[i + start] = bytes[i % len]
    }
  }

  return this
}

// HELPER FUNCTIONS
// ================

var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g

function base64clean (str) {
  // Node takes equal signs as end of the Base64 encoding
  str = str.split('=')[0]
  // Node strips out invalid characters like \n and \t from the string, base64-js does not
  str = str.trim().replace(INVALID_BASE64_RE, '')
  // Node converts strings with length < 2 to ''
  if (str.length < 2) return ''
  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
  while (str.length % 4 !== 0) {
    str = str + '='
  }
  return str
}

function toHex (n) {
  if (n < 16) return '0' + n.toString(16)
  return n.toString(16)
}

function utf8ToBytes (string, units) {
  units = units || Infinity
  var codePoint
  var length = string.length
  var leadSurrogate = null
  var bytes = []

  for (var i = 0; i < length; ++i) {
    codePoint = string.charCodeAt(i)

    // is surrogate component
    if (codePoint > 0xD7FF && codePoint < 0xE000) {
      // last char was a lead
      if (!leadSurrogate) {
        // no lead yet
        if (codePoint > 0xDBFF) {
          // unexpected trail
          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
          continue
        } else if (i + 1 === length) {
          // unpaired lead
          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
          continue
        }

        // valid lead
        leadSurrogate = codePoint

        continue
      }

      // 2 leads in a row
      if (codePoint < 0xDC00) {
        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
        leadSurrogate = codePoint
        continue
      }

      // valid surrogate pair
      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
    } else if (leadSurrogate) {
      // valid bmp char, but last char was a lead
      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
    }

    leadSurrogate = null

    // encode utf8
    if (codePoint < 0x80) {
      if ((units -= 1) < 0) break
      bytes.push(codePoint)
    } else if (codePoint < 0x800) {
      if ((units -= 2) < 0) break
      bytes.push(
        codePoint >> 0x6 | 0xC0,
        codePoint & 0x3F | 0x80
      )
    } else if (codePoint < 0x10000) {
      if ((units -= 3) < 0) break
      bytes.push(
        codePoint >> 0xC | 0xE0,
        codePoint >> 0x6 & 0x3F | 0x80,
        codePoint & 0x3F | 0x80
      )
    } else if (codePoint < 0x110000) {
      if ((units -= 4) < 0) break
      bytes.push(
        codePoint >> 0x12 | 0xF0,
        codePoint >> 0xC & 0x3F | 0x80,
        codePoint >> 0x6 & 0x3F | 0x80,
        codePoint & 0x3F | 0x80
      )
    } else {
      throw new Error('Invalid code point')
    }
  }

  return bytes
}

function asciiToBytes (str) {
  var byteArray = []
  for (var i = 0; i < str.length; ++i) {
    // Node's code seems to be doing this and not & 0x7F..
    byteArray.push(str.charCodeAt(i) & 0xFF)
  }
  return byteArray
}

function utf16leToBytes (str, units) {
  var c, hi, lo
  var byteArray = []
  for (var i = 0; i < str.length; ++i) {
    if ((units -= 2) < 0) break

    c = str.charCodeAt(i)
    hi = c >> 8
    lo = c % 256
    byteArray.push(lo)
    byteArray.push(hi)
  }

  return byteArray
}

function base64ToBytes (str) {
  return base64.toByteArray(base64clean(str))
}

function blitBuffer (src, dst, offset, length) {
  for (var i = 0; i < length; ++i) {
    if ((i + offset >= dst.length) || (i >= src.length)) break
    dst[i + offset] = src[i]
  }
  return i
}

// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
// the `instanceof` check but they should be treated as of that type.
// See: https://github.com/feross/buffer/issues/166
function isInstance (obj, type) {
  return obj instanceof type ||
    (obj != null && obj.constructor != null && obj.constructor.name != null &&
      obj.constructor.name === type.name)
}
function numberIsNaN (obj) {
  // For IE11 support
  return obj !== obj // eslint-disable-line no-self-compare
}

}).call(this)}).call(this,require("buffer").Buffer)

},{"base64-js":77,"buffer":81,"ieee754":86}],82:[function(require,module,exports){
module.exports = {
  "100": "Continue",
  "101": "Switching Protocols",
  "102": "Processing",
  "200": "OK",
  "201": "Created",
  "202": "Accepted",
  "203": "Non-Authoritative Information",
  "204": "No Content",
  "205": "Reset Content",
  "206": "Partial Content",
  "207": "Multi-Status",
  "208": "Already Reported",
  "226": "IM Used",
  "300": "Multiple Choices",
  "301": "Moved Permanently",
  "302": "Found",
  "303": "See Other",
  "304": "Not Modified",
  "305": "Use Proxy",
  "307": "Temporary Redirect",
  "308": "Permanent Redirect",
  "400": "Bad Request",
  "401": "Unauthorized",
  "402": "Payment Required",
  "403": "Forbidden",
  "404": "Not Found",
  "405": "Method Not Allowed",
  "406": "Not Acceptable",
  "407": "Proxy Authentication Required",
  "408": "Request Timeout",
  "409": "Conflict",
  "410": "Gone",
  "411": "Length Required",
  "412": "Precondition Failed",
  "413": "Payload Too Large",
  "414": "URI Too Long",
  "415": "Unsupported Media Type",
  "416": "Range Not Satisfiable",
  "417": "Expectation Failed",
  "418": "I'm a teapot",
  "421": "Misdirected Request",
  "422": "Unprocessable Entity",
  "423": "Locked",
  "424": "Failed Dependency",
  "425": "Unordered Collection",
  "426": "Upgrade Required",
  "428": "Precondition Required",
  "429": "Too Many Requests",
  "431": "Request Header Fields Too Large",
  "451": "Unavailable For Legal Reasons",
  "500": "Internal Server Error",
  "501": "Not Implemented",
  "502": "Bad Gateway",
  "503": "Service Unavailable",
  "504": "Gateway Timeout",
  "505": "HTTP Version Not Supported",
  "506": "Variant Also Negotiates",
  "507": "Insufficient Storage",
  "508": "Loop Detected",
  "509": "Bandwidth Limit Exceeded",
  "510": "Not Extended",
  "511": "Network Authentication Required"
}

},{}],83:[function(require,module,exports){
/*
 Copyright 2013-2014 Daniel Wirtz <dcode@dcode.io>

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */

/**
 * @license bytebuffer.js (c) 2015 Daniel Wirtz <dcode@dcode.io>
 * Backing buffer: ArrayBuffer, Accessor: Uint8Array
 * Released under the Apache License, Version 2.0
 * see: https://github.com/dcodeIO/bytebuffer.js for details
 */
(function(global, factory) {

    /* AMD */ if (typeof define === 'function' && define["amd"])
        define(["long"], factory);
    /* CommonJS */ else if (typeof require === 'function' && typeof module === "object" && module && module["exports"])
        module['exports'] = (function() {
            var Long; try { Long = require("long"); } catch (e) {}
            return factory(Long);
        })();
    /* Global */ else
        (global["dcodeIO"] = global["dcodeIO"] || {})["ByteBuffer"] = factory(global["dcodeIO"]["Long"]);

})(this, function(Long) {
    "use strict";

    /**
     * Constructs a new ByteBuffer.
     * @class The swiss army knife for binary data in JavaScript.
     * @exports ByteBuffer
     * @constructor
     * @param {number=} capacity Initial capacity. Defaults to {@link ByteBuffer.DEFAULT_CAPACITY}.
     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
     *  {@link ByteBuffer.DEFAULT_ENDIAN}.
     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to
     *  {@link ByteBuffer.DEFAULT_NOASSERT}.
     * @expose
     */
    var ByteBuffer = function(capacity, littleEndian, noAssert) {
        if (typeof capacity === 'undefined')
            capacity = ByteBuffer.DEFAULT_CAPACITY;
        if (typeof littleEndian === 'undefined')
            littleEndian = ByteBuffer.DEFAULT_ENDIAN;
        if (typeof noAssert === 'undefined')
            noAssert = ByteBuffer.DEFAULT_NOASSERT;
        if (!noAssert) {
            capacity = capacity | 0;
            if (capacity < 0)
                throw RangeError("Illegal capacity");
            littleEndian = !!littleEndian;
            noAssert = !!noAssert;
        }

        /**
         * Backing ArrayBuffer.
         * @type {!ArrayBuffer}
         * @expose
         */
        this.buffer = capacity === 0 ? EMPTY_BUFFER : new ArrayBuffer(capacity);

        /**
         * Uint8Array utilized to manipulate the backing buffer. Becomes `null` if the backing buffer has a capacity of `0`.
         * @type {?Uint8Array}
         * @expose
         */
        this.view = capacity === 0 ? null : new Uint8Array(this.buffer);

        /**
         * Absolute read/write offset.
         * @type {number}
         * @expose
         * @see ByteBuffer#flip
         * @see ByteBuffer#clear
         */
        this.offset = 0;

        /**
         * Marked offset.
         * @type {number}
         * @expose
         * @see ByteBuffer#mark
         * @see ByteBuffer#reset
         */
        this.markedOffset = -1;

        /**
         * Absolute limit of the contained data. Set to the backing buffer's capacity upon allocation.
         * @type {number}
         * @expose
         * @see ByteBuffer#flip
         * @see ByteBuffer#clear
         */
        this.limit = capacity;

        /**
         * Whether to use little endian byte order, defaults to `false` for big endian.
         * @type {boolean}
         * @expose
         */
        this.littleEndian = littleEndian;

        /**
         * Whether to skip assertions of offsets and values, defaults to `false`.
         * @type {boolean}
         * @expose
         */
        this.noAssert = noAssert;
    };

    /**
     * ByteBuffer version.
     * @type {string}
     * @const
     * @expose
     */
    ByteBuffer.VERSION = "5.0.1";

    /**
     * Little endian constant that can be used instead of its boolean value. Evaluates to `true`.
     * @type {boolean}
     * @const
     * @expose
     */
    ByteBuffer.LITTLE_ENDIAN = true;

    /**
     * Big endian constant that can be used instead of its boolean value. Evaluates to `false`.
     * @type {boolean}
     * @const
     * @expose
     */
    ByteBuffer.BIG_ENDIAN = false;

    /**
     * Default initial capacity of `16`.
     * @type {number}
     * @expose
     */
    ByteBuffer.DEFAULT_CAPACITY = 16;

    /**
     * Default endianess of `false` for big endian.
     * @type {boolean}
     * @expose
     */
    ByteBuffer.DEFAULT_ENDIAN = ByteBuffer.BIG_ENDIAN;

    /**
     * Default no assertions flag of `false`.
     * @type {boolean}
     * @expose
     */
    ByteBuffer.DEFAULT_NOASSERT = false;

    /**
     * A `Long` class for representing a 64-bit two's-complement integer value. May be `null` if Long.js has not been loaded
     *  and int64 support is not available.
     * @type {?Long}
     * @const
     * @see https://github.com/dcodeIO/long.js
     * @expose
     */
    ByteBuffer.Long = Long || null;

    /**
     * @alias ByteBuffer.prototype
     * @inner
     */
    var ByteBufferPrototype = ByteBuffer.prototype;

    /**
     * An indicator used to reliably determine if an object is a ByteBuffer or not.
     * @type {boolean}
     * @const
     * @expose
     * @private
     */
    ByteBufferPrototype.__isByteBuffer__;

    Object.defineProperty(ByteBufferPrototype, "__isByteBuffer__", {
        value: true,
        enumerable: false,
        configurable: false
    });

    // helpers

    /**
     * @type {!ArrayBuffer}
     * @inner
     */
    var EMPTY_BUFFER = new ArrayBuffer(0);

    /**
     * String.fromCharCode reference for compile-time renaming.
     * @type {function(...number):string}
     * @inner
     */
    var stringFromCharCode = String.fromCharCode;

    /**
     * Creates a source function for a string.
     * @param {string} s String to read from
     * @returns {function():number|null} Source function returning the next char code respectively `null` if there are
     *  no more characters left.
     * @throws {TypeError} If the argument is invalid
     * @inner
     */
    function stringSource(s) {
        var i=0; return function() {
            return i < s.length ? s.charCodeAt(i++) : null;
        };
    }

    /**
     * Creates a destination function for a string.
     * @returns {function(number=):undefined|string} Destination function successively called with the next char code.
     *  Returns the final string when called without arguments.
     * @inner
     */
    function stringDestination() {
        var cs = [], ps = []; return function() {
            if (arguments.length === 0)
                return ps.join('')+stringFromCharCode.apply(String, cs);
            if (cs.length + arguments.length > 1024)
                ps.push(stringFromCharCode.apply(String, cs)),
                    cs.length = 0;
            Array.prototype.push.apply(cs, arguments);
        };
    }

    /**
     * Gets the accessor type.
     * @returns {Function} `Buffer` under node.js, `Uint8Array` respectively `DataView` in the browser (classes)
     * @expose
     */
    ByteBuffer.accessor = function() {
        return Uint8Array;
    };
    /**
     * Allocates a new ByteBuffer backed by a buffer of the specified capacity.
     * @param {number=} capacity Initial capacity. Defaults to {@link ByteBuffer.DEFAULT_CAPACITY}.
     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
     *  {@link ByteBuffer.DEFAULT_ENDIAN}.
     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to
     *  {@link ByteBuffer.DEFAULT_NOASSERT}.
     * @returns {!ByteBuffer}
     * @expose
     */
    ByteBuffer.allocate = function(capacity, littleEndian, noAssert) {
        return new ByteBuffer(capacity, littleEndian, noAssert);
    };

    /**
     * Concatenates multiple ByteBuffers into one.
     * @param {!Array.<!ByteBuffer|!ArrayBuffer|!Uint8Array|string>} buffers Buffers to concatenate
     * @param {(string|boolean)=} encoding String encoding if `buffers` contains a string ("base64", "hex", "binary",
     *  defaults to "utf8")
     * @param {boolean=} littleEndian Whether to use little or big endian byte order for the resulting ByteBuffer. Defaults
     *  to {@link ByteBuffer.DEFAULT_ENDIAN}.
     * @param {boolean=} noAssert Whether to skip assertions of offsets and values for the resulting ByteBuffer. Defaults to
     *  {@link ByteBuffer.DEFAULT_NOASSERT}.
     * @returns {!ByteBuffer} Concatenated ByteBuffer
     * @expose
     */
    ByteBuffer.concat = function(buffers, encoding, littleEndian, noAssert) {
        if (typeof encoding === 'boolean' || typeof encoding !== 'string') {
            noAssert = littleEndian;
            littleEndian = encoding;
            encoding = undefined;
        }
        var capacity = 0;
        for (var i=0, k=buffers.length, length; i<k; ++i) {
            if (!ByteBuffer.isByteBuffer(buffers[i]))
                buffers[i] = ByteBuffer.wrap(buffers[i], encoding);
            length = buffers[i].limit - buffers[i].offset;
            if (length > 0) capacity += length;
        }
        if (capacity === 0)
            return new ByteBuffer(0, littleEndian, noAssert);
        var bb = new ByteBuffer(capacity, littleEndian, noAssert),
            bi;
        i=0; while (i<k) {
            bi = buffers[i++];
            length = bi.limit - bi.offset;
            if (length <= 0) continue;
            bb.view.set(bi.view.subarray(bi.offset, bi.limit), bb.offset);
            bb.offset += length;
        }
        bb.limit = bb.offset;
        bb.offset = 0;
        return bb;
    };

    /**
     * Tests if the specified type is a ByteBuffer.
     * @param {*} bb ByteBuffer to test
     * @returns {boolean} `true` if it is a ByteBuffer, otherwise `false`
     * @expose
     */
    ByteBuffer.isByteBuffer = function(bb) {
        return (bb && bb["__isByteBuffer__"]) === true;
    };
    /**
     * Gets the backing buffer type.
     * @returns {Function} `Buffer` under node.js, `ArrayBuffer` in the browser (classes)
     * @expose
     */
    ByteBuffer.type = function() {
        return ArrayBuffer;
    };
    /**
     * Wraps a buffer or a string. Sets the allocated ByteBuffer's {@link ByteBuffer#offset} to `0` and its
     *  {@link ByteBuffer#limit} to the length of the wrapped data.
     * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string|!Array.<number>} buffer Anything that can be wrapped
     * @param {(string|boolean)=} encoding String encoding if `buffer` is a string ("base64", "hex", "binary", defaults to
     *  "utf8")
     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
     *  {@link ByteBuffer.DEFAULT_ENDIAN}.
     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to
     *  {@link ByteBuffer.DEFAULT_NOASSERT}.
     * @returns {!ByteBuffer} A ByteBuffer wrapping `buffer`
     * @expose
     */
    ByteBuffer.wrap = function(buffer, encoding, littleEndian, noAssert) {
        if (typeof encoding !== 'string') {
            noAssert = littleEndian;
            littleEndian = encoding;
            encoding = undefined;
        }
        if (typeof buffer === 'string') {
            if (typeof encoding === 'undefined')
                encoding = "utf8";
            switch (encoding) {
                case "base64":
                    return ByteBuffer.fromBase64(buffer, littleEndian);
                case "hex":
                    return ByteBuffer.fromHex(buffer, littleEndian);
                case "binary":
                    return ByteBuffer.fromBinary(buffer, littleEndian);
                case "utf8":
                    return ByteBuffer.fromUTF8(buffer, littleEndian);
                case "debug":
                    return ByteBuffer.fromDebug(buffer, littleEndian);
                default:
                    throw Error("Unsupported encoding: "+encoding);
            }
        }
        if (buffer === null || typeof buffer !== 'object')
            throw TypeError("Illegal buffer");
        var bb;
        if (ByteBuffer.isByteBuffer(buffer)) {
            bb = ByteBufferPrototype.clone.call(buffer);
            bb.markedOffset = -1;
            return bb;
        }
        if (buffer instanceof Uint8Array) { // Extract ArrayBuffer from Uint8Array
            bb = new ByteBuffer(0, littleEndian, noAssert);
            if (buffer.length > 0) { // Avoid references to more than one EMPTY_BUFFER
                bb.buffer = buffer.buffer;
                bb.offset = buffer.byteOffset;
                bb.limit = buffer.byteOffset + buffer.byteLength;
                bb.view = new Uint8Array(buffer.buffer);
            }
        } else if (buffer instanceof ArrayBuffer) { // Reuse ArrayBuffer
            bb = new ByteBuffer(0, littleEndian, noAssert);
            if (buffer.byteLength > 0) {
                bb.buffer = buffer;
                bb.offset = 0;
                bb.limit = buffer.byteLength;
                bb.view = buffer.byteLength > 0 ? new Uint8Array(buffer) : null;
            }
        } else if (Object.prototype.toString.call(buffer) === "[object Array]") { // Create from octets
            bb = new ByteBuffer(buffer.length, littleEndian, noAssert);
            bb.limit = buffer.length;
            for (var i=0; i<buffer.length; ++i)
                bb.view[i] = buffer[i];
        } else
            throw TypeError("Illegal buffer"); // Otherwise fail
        return bb;
    };

    /**
     * Writes the array as a bitset.
     * @param {Array<boolean>} value Array of booleans to write
     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.
     * @returns {!ByteBuffer}
     * @expose
     */
    ByteBufferPrototype.writeBitSet = function(value, offset) {
      var relative = typeof offset === 'undefined';
      if (relative) offset = this.offset;
      if (!this.noAssert) {
        if (!(value instanceof Array))
          throw TypeError("Illegal BitSet: Not an array");
        if (typeof offset !== 'number' || offset % 1 !== 0)
            throw TypeError("Illegal offset: "+offset+" (not an integer)");
        offset >>>= 0;
        if (offset < 0 || offset + 0 > this.buffer.byteLength)
            throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
      }

      var start = offset,
          bits = value.length,
          bytes = (bits >> 3),
          bit = 0,
          k;

      offset += this.writeVarint32(bits,offset);

      while(bytes--) {
        k = (!!value[bit++] & 1) |
            ((!!value[bit++] & 1) << 1) |
            ((!!value[bit++] & 1) << 2) |
            ((!!value[bit++] & 1) << 3) |
            ((!!value[bit++] & 1) << 4) |
            ((!!value[bit++] & 1) << 5) |
            ((!!value[bit++] & 1) << 6) |
            ((!!value[bit++] & 1) << 7);
        this.writeByte(k,offset++);
      }

      if(bit < bits) {
        var m = 0; k = 0;
        while(bit < bits) k = k | ((!!value[bit++] & 1) << (m++));
        this.writeByte(k,offset++);
      }

      if (relative) {
        this.offset = offset;
        return this;
      }
      return offset - start;
    }

    /**
     * Reads a BitSet as an array of booleans.
     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.
     * @returns {Array<boolean>
     * @expose
     */
    ByteBufferPrototype.readBitSet = function(offset) {
      var relative = typeof offset === 'undefined';
      if (relative) offset = this.offset;

      var ret = this.readVarint32(offset),
          bits = ret.value,
          bytes = (bits >> 3),
          bit = 0,
          value = [],
          k;

      offset += ret.length;

      while(bytes--) {
        k = this.readByte(offset++);
        value[bit++] = !!(k & 0x01);
        value[bit++] = !!(k & 0x02);
        value[bit++] = !!(k & 0x04);
        value[bit++] = !!(k & 0x08);
        value[bit++] = !!(k & 0x10);
        value[bit++] = !!(k & 0x20);
        value[bit++] = !!(k & 0x40);
        value[bit++] = !!(k & 0x80);
      }

      if(bit < bits) {
        var m = 0;
        k = this.readByte(offset++);
        while(bit < bits) value[bit++] = !!((k >> (m++)) & 1);
      }

      if (relative) {
        this.offset = offset;
      }
      return value;
    }
    /**
     * Reads the specified number of bytes.
     * @param {number} length Number of bytes to read
     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.
     * @returns {!ByteBuffer}
     * @expose
     */
    ByteBufferPrototype.readBytes = function(length, offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + length > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+length+") <= "+this.buffer.byteLength);
        }
        var slice = this.slice(offset, offset + length);
        if (relative) this.offset += length;
        return slice;
    };

    /**
     * Writes a payload of bytes. This is an alias of {@link ByteBuffer#append}.
     * @function
     * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string} source Data to write. If `source` is a ByteBuffer, its offsets
     *  will be modified according to the performed read operation.
     * @param {(string|number)=} encoding Encoding if `data` is a string ("base64", "hex", "binary", defaults to "utf8")
     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
     *  written if omitted.
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.writeBytes = ByteBufferPrototype.append;

    // types/ints/int8

    /**
     * Writes an 8bit signed integer.
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.writeInt8 = function(value, offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof value !== 'number' || value % 1 !== 0)
                throw TypeError("Illegal value: "+value+" (not an integer)");
            value |= 0;
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 0 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
        }
        offset += 1;
        var capacity0 = this.buffer.byteLength;
        if (offset > capacity0)
            this.resize((capacity0 *= 2) > offset ? capacity0 : offset);
        offset -= 1;
        this.view[offset] = value;
        if (relative) this.offset += 1;
        return this;
    };

    /**
     * Writes an 8bit signed integer. This is an alias of {@link ByteBuffer#writeInt8}.
     * @function
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.writeByte = ByteBufferPrototype.writeInt8;

    /**
     * Reads an 8bit signed integer.
     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
     * @returns {number} Value read
     * @expose
     */
    ByteBufferPrototype.readInt8 = function(offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 1 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.byteLength);
        }
        var value = this.view[offset];
        if ((value & 0x80) === 0x80) value = -(0xFF - value + 1); // Cast to signed
        if (relative) this.offset += 1;
        return value;
    };

    /**
     * Reads an 8bit signed integer. This is an alias of {@link ByteBuffer#readInt8}.
     * @function
     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
     * @returns {number} Value read
     * @expose
     */
    ByteBufferPrototype.readByte = ByteBufferPrototype.readInt8;

    /**
     * Writes an 8bit unsigned integer.
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.writeUint8 = function(value, offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof value !== 'number' || value % 1 !== 0)
                throw TypeError("Illegal value: "+value+" (not an integer)");
            value >>>= 0;
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 0 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
        }
        offset += 1;
        var capacity1 = this.buffer.byteLength;
        if (offset > capacity1)
            this.resize((capacity1 *= 2) > offset ? capacity1 : offset);
        offset -= 1;
        this.view[offset] = value;
        if (relative) this.offset += 1;
        return this;
    };

    /**
     * Writes an 8bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint8}.
     * @function
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.writeUInt8 = ByteBufferPrototype.writeUint8;

    /**
     * Reads an 8bit unsigned integer.
     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
     * @returns {number} Value read
     * @expose
     */
    ByteBufferPrototype.readUint8 = function(offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 1 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.byteLength);
        }
        var value = this.view[offset];
        if (relative) this.offset += 1;
        return value;
    };

    /**
     * Reads an 8bit unsigned integer. This is an alias of {@link ByteBuffer#readUint8}.
     * @function
     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
     * @returns {number} Value read
     * @expose
     */
    ByteBufferPrototype.readUInt8 = ByteBufferPrototype.readUint8;

    // types/ints/int16

    /**
     * Writes a 16bit signed integer.
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
     * @throws {TypeError} If `offset` or `value` is not a valid number
     * @throws {RangeError} If `offset` is out of bounds
     * @expose
     */
    ByteBufferPrototype.writeInt16 = function(value, offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof value !== 'number' || value % 1 !== 0)
                throw TypeError("Illegal value: "+value+" (not an integer)");
            value |= 0;
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 0 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
        }
        offset += 2;
        var capacity2 = this.buffer.byteLength;
        if (offset > capacity2)
            this.resize((capacity2 *= 2) > offset ? capacity2 : offset);
        offset -= 2;
        if (this.littleEndian) {
            this.view[offset+1] = (value & 0xFF00) >>> 8;
            this.view[offset  ] =  value & 0x00FF;
        } else {
            this.view[offset]   = (value & 0xFF00) >>> 8;
            this.view[offset+1] =  value & 0x00FF;
        }
        if (relative) this.offset += 2;
        return this;
    };

    /**
     * Writes a 16bit signed integer. This is an alias of {@link ByteBuffer#writeInt16}.
     * @function
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
     * @throws {TypeError} If `offset` or `value` is not a valid number
     * @throws {RangeError} If `offset` is out of bounds
     * @expose
     */
    ByteBufferPrototype.writeShort = ByteBufferPrototype.writeInt16;

    /**
     * Reads a 16bit signed integer.
     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
     * @returns {number} Value read
     * @throws {TypeError} If `offset` is not a valid number
     * @throws {RangeError} If `offset` is out of bounds
     * @expose
     */
    ByteBufferPrototype.readInt16 = function(offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 2 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+2+") <= "+this.buffer.byteLength);
        }
        var value = 0;
        if (this.littleEndian) {
            value  = this.view[offset  ];
            value |= this.view[offset+1] << 8;
        } else {
            value  = this.view[offset  ] << 8;
            value |= this.view[offset+1];
        }
        if ((value & 0x8000) === 0x8000) value = -(0xFFFF - value + 1); // Cast to signed
        if (relative) this.offset += 2;
        return value;
    };

    /**
     * Reads a 16bit signed integer. This is an alias of {@link ByteBuffer#readInt16}.
     * @function
     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
     * @returns {number} Value read
     * @throws {TypeError} If `offset` is not a valid number
     * @throws {RangeError} If `offset` is out of bounds
     * @expose
     */
    ByteBufferPrototype.readShort = ByteBufferPrototype.readInt16;

    /**
     * Writes a 16bit unsigned integer.
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
     * @throws {TypeError} If `offset` or `value` is not a valid number
     * @throws {RangeError} If `offset` is out of bounds
     * @expose
     */
    ByteBufferPrototype.writeUint16 = function(value, offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof value !== 'number' || value % 1 !== 0)
                throw TypeError("Illegal value: "+value+" (not an integer)");
            value >>>= 0;
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 0 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
        }
        offset += 2;
        var capacity3 = this.buffer.byteLength;
        if (offset > capacity3)
            this.resize((capacity3 *= 2) > offset ? capacity3 : offset);
        offset -= 2;
        if (this.littleEndian) {
            this.view[offset+1] = (value & 0xFF00) >>> 8;
            this.view[offset  ] =  value & 0x00FF;
        } else {
            this.view[offset]   = (value & 0xFF00) >>> 8;
            this.view[offset+1] =  value & 0x00FF;
        }
        if (relative) this.offset += 2;
        return this;
    };

    /**
     * Writes a 16bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint16}.
     * @function
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
     * @throws {TypeError} If `offset` or `value` is not a valid number
     * @throws {RangeError} If `offset` is out of bounds
     * @expose
     */
    ByteBufferPrototype.writeUInt16 = ByteBufferPrototype.writeUint16;

    /**
     * Reads a 16bit unsigned integer.
     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
     * @returns {number} Value read
     * @throws {TypeError} If `offset` is not a valid number
     * @throws {RangeError} If `offset` is out of bounds
     * @expose
     */
    ByteBufferPrototype.readUint16 = function(offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 2 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+2+") <= "+this.buffer.byteLength);
        }
        var value = 0;
        if (this.littleEndian) {
            value  = this.view[offset  ];
            value |= this.view[offset+1] << 8;
        } else {
            value  = this.view[offset  ] << 8;
            value |= this.view[offset+1];
        }
        if (relative) this.offset += 2;
        return value;
    };

    /**
     * Reads a 16bit unsigned integer. This is an alias of {@link ByteBuffer#readUint16}.
     * @function
     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
     * @returns {number} Value read
     * @throws {TypeError} If `offset` is not a valid number
     * @throws {RangeError} If `offset` is out of bounds
     * @expose
     */
    ByteBufferPrototype.readUInt16 = ByteBufferPrototype.readUint16;

    // types/ints/int32

    /**
     * Writes a 32bit signed integer.
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
     * @expose
     */
    ByteBufferPrototype.writeInt32 = function(value, offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof value !== 'number' || value % 1 !== 0)
                throw TypeError("Illegal value: "+value+" (not an integer)");
            value |= 0;
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 0 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
        }
        offset += 4;
        var capacity4 = this.buffer.byteLength;
        if (offset > capacity4)
            this.resize((capacity4 *= 2) > offset ? capacity4 : offset);
        offset -= 4;
        if (this.littleEndian) {
            this.view[offset+3] = (value >>> 24) & 0xFF;
            this.view[offset+2] = (value >>> 16) & 0xFF;
            this.view[offset+1] = (value >>>  8) & 0xFF;
            this.view[offset  ] =  value         & 0xFF;
        } else {
            this.view[offset  ] = (value >>> 24) & 0xFF;
            this.view[offset+1] = (value >>> 16) & 0xFF;
            this.view[offset+2] = (value >>>  8) & 0xFF;
            this.view[offset+3] =  value         & 0xFF;
        }
        if (relative) this.offset += 4;
        return this;
    };

    /**
     * Writes a 32bit signed integer. This is an alias of {@link ByteBuffer#writeInt32}.
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
     * @expose
     */
    ByteBufferPrototype.writeInt = ByteBufferPrototype.writeInt32;

    /**
     * Reads a 32bit signed integer.
     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
     * @returns {number} Value read
     * @expose
     */
    ByteBufferPrototype.readInt32 = function(offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 4 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+4+") <= "+this.buffer.byteLength);
        }
        var value = 0;
        if (this.littleEndian) {
            value  = this.view[offset+2] << 16;
            value |= this.view[offset+1] <<  8;
            value |= this.view[offset  ];
            value += this.view[offset+3] << 24 >>> 0;
        } else {
            value  = this.view[offset+1] << 16;
            value |= this.view[offset+2] <<  8;
            value |= this.view[offset+3];
            value += this.view[offset  ] << 24 >>> 0;
        }
        value |= 0; // Cast to signed
        if (relative) this.offset += 4;
        return value;
    };

    /**
     * Reads a 32bit signed integer. This is an alias of {@link ByteBuffer#readInt32}.
     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `4` if omitted.
     * @returns {number} Value read
     * @expose
     */
    ByteBufferPrototype.readInt = ByteBufferPrototype.readInt32;

    /**
     * Writes a 32bit unsigned integer.
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
     * @expose
     */
    ByteBufferPrototype.writeUint32 = function(value, offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof value !== 'number' || value % 1 !== 0)
                throw TypeError("Illegal value: "+value+" (not an integer)");
            value >>>= 0;
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 0 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
        }
        offset += 4;
        var capacity5 = this.buffer.byteLength;
        if (offset > capacity5)
            this.resize((capacity5 *= 2) > offset ? capacity5 : offset);
        offset -= 4;
        if (this.littleEndian) {
            this.view[offset+3] = (value >>> 24) & 0xFF;
            this.view[offset+2] = (value >>> 16) & 0xFF;
            this.view[offset+1] = (value >>>  8) & 0xFF;
            this.view[offset  ] =  value         & 0xFF;
        } else {
            this.view[offset  ] = (value >>> 24) & 0xFF;
            this.view[offset+1] = (value >>> 16) & 0xFF;
            this.view[offset+2] = (value >>>  8) & 0xFF;
            this.view[offset+3] =  value         & 0xFF;
        }
        if (relative) this.offset += 4;
        return this;
    };

    /**
     * Writes a 32bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint32}.
     * @function
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
     * @expose
     */
    ByteBufferPrototype.writeUInt32 = ByteBufferPrototype.writeUint32;

    /**
     * Reads a 32bit unsigned integer.
     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
     * @returns {number} Value read
     * @expose
     */
    ByteBufferPrototype.readUint32 = function(offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 4 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+4+") <= "+this.buffer.byteLength);
        }
        var value = 0;
        if (this.littleEndian) {
            value  = this.view[offset+2] << 16;
            value |= this.view[offset+1] <<  8;
            value |= this.view[offset  ];
            value += this.view[offset+3] << 24 >>> 0;
        } else {
            value  = this.view[offset+1] << 16;
            value |= this.view[offset+2] <<  8;
            value |= this.view[offset+3];
            value += this.view[offset  ] << 24 >>> 0;
        }
        if (relative) this.offset += 4;
        return value;
    };

    /**
     * Reads a 32bit unsigned integer. This is an alias of {@link ByteBuffer#readUint32}.
     * @function
     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
     * @returns {number} Value read
     * @expose
     */
    ByteBufferPrototype.readUInt32 = ByteBufferPrototype.readUint32;

    // types/ints/int64

    if (Long) {

        /**
         * Writes a 64bit signed integer.
         * @param {number|!Long} value Value to write
         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
         * @returns {!ByteBuffer} this
         * @expose
         */
        ByteBufferPrototype.writeInt64 = function(value, offset) {
            var relative = typeof offset === 'undefined';
            if (relative) offset = this.offset;
            if (!this.noAssert) {
                if (typeof value === 'number')
                    value = Long.fromNumber(value);
                else if (typeof value === 'string')
                    value = Long.fromString(value);
                else if (!(value && value instanceof Long))
                    throw TypeError("Illegal value: "+value+" (not an integer or Long)");
                if (typeof offset !== 'number' || offset % 1 !== 0)
                    throw TypeError("Illegal offset: "+offset+" (not an integer)");
                offset >>>= 0;
                if (offset < 0 || offset + 0 > this.buffer.byteLength)
                    throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
            }
            if (typeof value === 'number')
                value = Long.fromNumber(value);
            else if (typeof value === 'string')
                value = Long.fromString(value);
            offset += 8;
            var capacity6 = this.buffer.byteLength;
            if (offset > capacity6)
                this.resize((capacity6 *= 2) > offset ? capacity6 : offset);
            offset -= 8;
            var lo = value.low,
                hi = value.high;
            if (this.littleEndian) {
                this.view[offset+3] = (lo >>> 24) & 0xFF;
                this.view[offset+2] = (lo >>> 16) & 0xFF;
                this.view[offset+1] = (lo >>>  8) & 0xFF;
                this.view[offset  ] =  lo         & 0xFF;
                offset += 4;
                this.view[offset+3] = (hi >>> 24) & 0xFF;
                this.view[offset+2] = (hi >>> 16) & 0xFF;
                this.view[offset+1] = (hi >>>  8) & 0xFF;
                this.view[offset  ] =  hi         & 0xFF;
            } else {
                this.view[offset  ] = (hi >>> 24) & 0xFF;
                this.view[offset+1] = (hi >>> 16) & 0xFF;
                this.view[offset+2] = (hi >>>  8) & 0xFF;
                this.view[offset+3] =  hi         & 0xFF;
                offset += 4;
                this.view[offset  ] = (lo >>> 24) & 0xFF;
                this.view[offset+1] = (lo >>> 16) & 0xFF;
                this.view[offset+2] = (lo >>>  8) & 0xFF;
                this.view[offset+3] =  lo         & 0xFF;
            }
            if (relative) this.offset += 8;
            return this;
        };

        /**
         * Writes a 64bit signed integer. This is an alias of {@link ByteBuffer#writeInt64}.
         * @param {number|!Long} value Value to write
         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
         * @returns {!ByteBuffer} this
         * @expose
         */
        ByteBufferPrototype.writeLong = ByteBufferPrototype.writeInt64;

        /**
         * Reads a 64bit signed integer.
         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
         * @returns {!Long}
         * @expose
         */
        ByteBufferPrototype.readInt64 = function(offset) {
            var relative = typeof offset === 'undefined';
            if (relative) offset = this.offset;
            if (!this.noAssert) {
                if (typeof offset !== 'number' || offset % 1 !== 0)
                    throw TypeError("Illegal offset: "+offset+" (not an integer)");
                offset >>>= 0;
                if (offset < 0 || offset + 8 > this.buffer.byteLength)
                    throw RangeError("Illegal offset: 0 <= "+offset+" (+"+8+") <= "+this.buffer.byteLength);
            }
            var lo = 0,
                hi = 0;
            if (this.littleEndian) {
                lo  = this.view[offset+2] << 16;
                lo |= this.view[offset+1] <<  8;
                lo |= this.view[offset  ];
                lo += this.view[offset+3] << 24 >>> 0;
                offset += 4;
                hi  = this.view[offset+2] << 16;
                hi |= this.view[offset+1] <<  8;
                hi |= this.view[offset  ];
                hi += this.view[offset+3] << 24 >>> 0;
            } else {
                hi  = this.view[offset+1] << 16;
                hi |= this.view[offset+2] <<  8;
                hi |= this.view[offset+3];
                hi += this.view[offset  ] << 24 >>> 0;
                offset += 4;
                lo  = this.view[offset+1] << 16;
                lo |= this.view[offset+2] <<  8;
                lo |= this.view[offset+3];
                lo += this.view[offset  ] << 24 >>> 0;
            }
            var value = new Long(lo, hi, false);
            if (relative) this.offset += 8;
            return value;
        };

        /**
         * Reads a 64bit signed integer. This is an alias of {@link ByteBuffer#readInt64}.
         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
         * @returns {!Long}
         * @expose
         */
        ByteBufferPrototype.readLong = ByteBufferPrototype.readInt64;

        /**
         * Writes a 64bit unsigned integer.
         * @param {number|!Long} value Value to write
         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
         * @returns {!ByteBuffer} this
         * @expose
         */
        ByteBufferPrototype.writeUint64 = function(value, offset) {
            var relative = typeof offset === 'undefined';
            if (relative) offset = this.offset;
            if (!this.noAssert) {
                if (typeof value === 'number')
                    value = Long.fromNumber(value);
                else if (typeof value === 'string')
                    value = Long.fromString(value);
                else if (!(value && value instanceof Long))
                    throw TypeError("Illegal value: "+value+" (not an integer or Long)");
                if (typeof offset !== 'number' || offset % 1 !== 0)
                    throw TypeError("Illegal offset: "+offset+" (not an integer)");
                offset >>>= 0;
                if (offset < 0 || offset + 0 > this.buffer.byteLength)
                    throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
            }
            if (typeof value === 'number')
                value = Long.fromNumber(value);
            else if (typeof value === 'string')
                value = Long.fromString(value);
            offset += 8;
            var capacity7 = this.buffer.byteLength;
            if (offset > capacity7)
                this.resize((capacity7 *= 2) > offset ? capacity7 : offset);
            offset -= 8;
            var lo = value.low,
                hi = value.high;
            if (this.littleEndian) {
                this.view[offset+3] = (lo >>> 24) & 0xFF;
                this.view[offset+2] = (lo >>> 16) & 0xFF;
                this.view[offset+1] = (lo >>>  8) & 0xFF;
                this.view[offset  ] =  lo         & 0xFF;
                offset += 4;
                this.view[offset+3] = (hi >>> 24) & 0xFF;
                this.view[offset+2] = (hi >>> 16) & 0xFF;
                this.view[offset+1] = (hi >>>  8) & 0xFF;
                this.view[offset  ] =  hi         & 0xFF;
            } else {
                this.view[offset  ] = (hi >>> 24) & 0xFF;
                this.view[offset+1] = (hi >>> 16) & 0xFF;
                this.view[offset+2] = (hi >>>  8) & 0xFF;
                this.view[offset+3] =  hi         & 0xFF;
                offset += 4;
                this.view[offset  ] = (lo >>> 24) & 0xFF;
                this.view[offset+1] = (lo >>> 16) & 0xFF;
                this.view[offset+2] = (lo >>>  8) & 0xFF;
                this.view[offset+3] =  lo         & 0xFF;
            }
            if (relative) this.offset += 8;
            return this;
        };

        /**
         * Writes a 64bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint64}.
         * @function
         * @param {number|!Long} value Value to write
         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
         * @returns {!ByteBuffer} this
         * @expose
         */
        ByteBufferPrototype.writeUInt64 = ByteBufferPrototype.writeUint64;

        /**
         * Reads a 64bit unsigned integer.
         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
         * @returns {!Long}
         * @expose
         */
        ByteBufferPrototype.readUint64 = function(offset) {
            var relative = typeof offset === 'undefined';
            if (relative) offset = this.offset;
            if (!this.noAssert) {
                if (typeof offset !== 'number' || offset % 1 !== 0)
                    throw TypeError("Illegal offset: "+offset+" (not an integer)");
                offset >>>= 0;
                if (offset < 0 || offset + 8 > this.buffer.byteLength)
                    throw RangeError("Illegal offset: 0 <= "+offset+" (+"+8+") <= "+this.buffer.byteLength);
            }
            var lo = 0,
                hi = 0;
            if (this.littleEndian) {
                lo  = this.view[offset+2] << 16;
                lo |= this.view[offset+1] <<  8;
                lo |= this.view[offset  ];
                lo += this.view[offset+3] << 24 >>> 0;
                offset += 4;
                hi  = this.view[offset+2] << 16;
                hi |= this.view[offset+1] <<  8;
                hi |= this.view[offset  ];
                hi += this.view[offset+3] << 24 >>> 0;
            } else {
                hi  = this.view[offset+1] << 16;
                hi |= this.view[offset+2] <<  8;
                hi |= this.view[offset+3];
                hi += this.view[offset  ] << 24 >>> 0;
                offset += 4;
                lo  = this.view[offset+1] << 16;
                lo |= this.view[offset+2] <<  8;
                lo |= this.view[offset+3];
                lo += this.view[offset  ] << 24 >>> 0;
            }
            var value = new Long(lo, hi, true);
            if (relative) this.offset += 8;
            return value;
        };

        /**
         * Reads a 64bit unsigned integer. This is an alias of {@link ByteBuffer#readUint64}.
         * @function
         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
         * @returns {!Long}
         * @expose
         */
        ByteBufferPrototype.readUInt64 = ByteBufferPrototype.readUint64;

    } // Long


    // types/floats/float32

    /*
     ieee754 - https://github.com/feross/ieee754

     The MIT License (MIT)

     Copyright (c) Feross Aboukhadijeh

     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"), to deal
     in the Software without restriction, including without limitation the rights
     to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
     copies of the Software, and to permit persons to whom the Software is
     furnished to do so, subject to the following conditions:

     The above copyright notice and this permission notice shall be included in
     all copies or substantial portions of the Software.

     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
     AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     THE SOFTWARE.
    */

    /**
     * Reads an IEEE754 float from a byte array.
     * @param {!Array} buffer
     * @param {number} offset
     * @param {boolean} isLE
     * @param {number} mLen
     * @param {number} nBytes
     * @returns {number}
     * @inner
     */
    function ieee754_read(buffer, offset, isLE, mLen, nBytes) {
        var e, m,
            eLen = nBytes * 8 - mLen - 1,
            eMax = (1 << eLen) - 1,
            eBias = eMax >> 1,
            nBits = -7,
            i = isLE ? (nBytes - 1) : 0,
            d = isLE ? -1 : 1,
            s = buffer[offset + i];

        i += d;

        e = s & ((1 << (-nBits)) - 1);
        s >>= (-nBits);
        nBits += eLen;
        for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}

        m = e & ((1 << (-nBits)) - 1);
        e >>= (-nBits);
        nBits += mLen;
        for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}

        if (e === 0) {
            e = 1 - eBias;
        } else if (e === eMax) {
            return m ? NaN : ((s ? -1 : 1) * Infinity);
        } else {
            m = m + Math.pow(2, mLen);
            e = e - eBias;
        }
        return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
    }

    /**
     * Writes an IEEE754 float to a byte array.
     * @param {!Array} buffer
     * @param {number} value
     * @param {number} offset
     * @param {boolean} isLE
     * @param {number} mLen
     * @param {number} nBytes
     * @inner
     */
    function ieee754_write(buffer, value, offset, isLE, mLen, nBytes) {
        var e, m, c,
            eLen = nBytes * 8 - mLen - 1,
            eMax = (1 << eLen) - 1,
            eBias = eMax >> 1,
            rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
            i = isLE ? 0 : (nBytes - 1),
            d = isLE ? 1 : -1,
            s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;

        value = Math.abs(value);

        if (isNaN(value) || value === Infinity) {
            m = isNaN(value) ? 1 : 0;
            e = eMax;
        } else {
            e = Math.floor(Math.log(value) / Math.LN2);
            if (value * (c = Math.pow(2, -e)) < 1) {
                e--;
                c *= 2;
            }
            if (e + eBias >= 1) {
                value += rt / c;
            } else {
                value += rt * Math.pow(2, 1 - eBias);
            }
            if (value * c >= 2) {
                e++;
                c /= 2;
            }

            if (e + eBias >= eMax) {
                m = 0;
                e = eMax;
            } else if (e + eBias >= 1) {
                m = (value * c - 1) * Math.pow(2, mLen);
                e = e + eBias;
            } else {
                m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
                e = 0;
            }
        }

        for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}

        e = (e << mLen) | m;
        eLen += mLen;
        for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}

        buffer[offset + i - d] |= s * 128;
    }

    /**
     * Writes a 32bit float.
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.writeFloat32 = function(value, offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof value !== 'number')
                throw TypeError("Illegal value: "+value+" (not a number)");
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 0 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
        }
        offset += 4;
        var capacity8 = this.buffer.byteLength;
        if (offset > capacity8)
            this.resize((capacity8 *= 2) > offset ? capacity8 : offset);
        offset -= 4;
        ieee754_write(this.view, value, offset, this.littleEndian, 23, 4);
        if (relative) this.offset += 4;
        return this;
    };

    /**
     * Writes a 32bit float. This is an alias of {@link ByteBuffer#writeFloat32}.
     * @function
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.writeFloat = ByteBufferPrototype.writeFloat32;

    /**
     * Reads a 32bit float.
     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
     * @returns {number}
     * @expose
     */
    ByteBufferPrototype.readFloat32 = function(offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 4 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+4+") <= "+this.buffer.byteLength);
        }
        var value = ieee754_read(this.view, offset, this.littleEndian, 23, 4);
        if (relative) this.offset += 4;
        return value;
    };

    /**
     * Reads a 32bit float. This is an alias of {@link ByteBuffer#readFloat32}.
     * @function
     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
     * @returns {number}
     * @expose
     */
    ByteBufferPrototype.readFloat = ByteBufferPrototype.readFloat32;

    // types/floats/float64

    /**
     * Writes a 64bit float.
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.writeFloat64 = function(value, offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof value !== 'number')
                throw TypeError("Illegal value: "+value+" (not a number)");
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 0 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
        }
        offset += 8;
        var capacity9 = this.buffer.byteLength;
        if (offset > capacity9)
            this.resize((capacity9 *= 2) > offset ? capacity9 : offset);
        offset -= 8;
        ieee754_write(this.view, value, offset, this.littleEndian, 52, 8);
        if (relative) this.offset += 8;
        return this;
    };

    /**
     * Writes a 64bit float. This is an alias of {@link ByteBuffer#writeFloat64}.
     * @function
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.writeDouble = ByteBufferPrototype.writeFloat64;

    /**
     * Reads a 64bit float.
     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
     * @returns {number}
     * @expose
     */
    ByteBufferPrototype.readFloat64 = function(offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 8 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+8+") <= "+this.buffer.byteLength);
        }
        var value = ieee754_read(this.view, offset, this.littleEndian, 52, 8);
        if (relative) this.offset += 8;
        return value;
    };

    /**
     * Reads a 64bit float. This is an alias of {@link ByteBuffer#readFloat64}.
     * @function
     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
     * @returns {number}
     * @expose
     */
    ByteBufferPrototype.readDouble = ByteBufferPrototype.readFloat64;


    // types/varints/varint32

    /**
     * Maximum number of bytes required to store a 32bit base 128 variable-length integer.
     * @type {number}
     * @const
     * @expose
     */
    ByteBuffer.MAX_VARINT32_BYTES = 5;

    /**
     * Calculates the actual number of bytes required to store a 32bit base 128 variable-length integer.
     * @param {number} value Value to encode
     * @returns {number} Number of bytes required. Capped to {@link ByteBuffer.MAX_VARINT32_BYTES}
     * @expose
     */
    ByteBuffer.calculateVarint32 = function(value) {
        // ref: src/google/protobuf/io/coded_stream.cc
        value = value >>> 0;
             if (value < 1 << 7 ) return 1;
        else if (value < 1 << 14) return 2;
        else if (value < 1 << 21) return 3;
        else if (value < 1 << 28) return 4;
        else                      return 5;
    };

    /**
     * Zigzag encodes a signed 32bit integer so that it can be effectively used with varint encoding.
     * @param {number} n Signed 32bit integer
     * @returns {number} Unsigned zigzag encoded 32bit integer
     * @expose
     */
    ByteBuffer.zigZagEncode32 = function(n) {
        return (((n |= 0) << 1) ^ (n >> 31)) >>> 0; // ref: src/google/protobuf/wire_format_lite.h
    };

    /**
     * Decodes a zigzag encoded signed 32bit integer.
     * @param {number} n Unsigned zigzag encoded 32bit integer
     * @returns {number} Signed 32bit integer
     * @expose
     */
    ByteBuffer.zigZagDecode32 = function(n) {
        return ((n >>> 1) ^ -(n & 1)) | 0; // // ref: src/google/protobuf/wire_format_lite.h
    };

    /**
     * Writes a 32bit base 128 variable-length integer.
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
     *  written if omitted.
     * @returns {!ByteBuffer|number} this if `offset` is omitted, else the actual number of bytes written
     * @expose
     */
    ByteBufferPrototype.writeVarint32 = function(value, offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof value !== 'number' || value % 1 !== 0)
                throw TypeError("Illegal value: "+value+" (not an integer)");
            value |= 0;
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 0 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
        }
        var size = ByteBuffer.calculateVarint32(value),
            b;
        offset += size;
        var capacity10 = this.buffer.byteLength;
        if (offset > capacity10)
            this.resize((capacity10 *= 2) > offset ? capacity10 : offset);
        offset -= size;
        value >>>= 0;
        while (value >= 0x80) {
            b = (value & 0x7f) | 0x80;
            this.view[offset++] = b;
            value >>>= 7;
        }
        this.view[offset++] = value;
        if (relative) {
            this.offset = offset;
            return this;
        }
        return size;
    };

    /**
     * Writes a zig-zag encoded (signed) 32bit base 128 variable-length integer.
     * @param {number} value Value to write
     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
     *  written if omitted.
     * @returns {!ByteBuffer|number} this if `offset` is omitted, else the actual number of bytes written
     * @expose
     */
    ByteBufferPrototype.writeVarint32ZigZag = function(value, offset) {
        return this.writeVarint32(ByteBuffer.zigZagEncode32(value), offset);
    };

    /**
     * Reads a 32bit base 128 variable-length integer.
     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
     *  written if omitted.
     * @returns {number|!{value: number, length: number}} The value read if offset is omitted, else the value read
     *  and the actual number of bytes read.
     * @throws {Error} If it's not a valid varint. Has a property `truncated = true` if there is not enough data available
     *  to fully decode the varint.
     * @expose
     */
    ByteBufferPrototype.readVarint32 = function(offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 1 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.byteLength);
        }
        var c = 0,
            value = 0 >>> 0,
            b;
        do {
            if (!this.noAssert && offset > this.limit) {
                var err = Error("Truncated");
                err['truncated'] = true;
                throw err;
            }
            b = this.view[offset++];
            if (c < 5)
                value |= (b & 0x7f) << (7*c);
            ++c;
        } while ((b & 0x80) !== 0);
        value |= 0;
        if (relative) {
            this.offset = offset;
            return value;
        }
        return {
            "value": value,
            "length": c
        };
    };

    /**
     * Reads a zig-zag encoded (signed) 32bit base 128 variable-length integer.
     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
     *  written if omitted.
     * @returns {number|!{value: number, length: number}} The value read if offset is omitted, else the value read
     *  and the actual number of bytes read.
     * @throws {Error} If it's not a valid varint
     * @expose
     */
    ByteBufferPrototype.readVarint32ZigZag = function(offset) {
        var val = this.readVarint32(offset);
        if (typeof val === 'object')
            val["value"] = ByteBuffer.zigZagDecode32(val["value"]);
        else
            val = ByteBuffer.zigZagDecode32(val);
        return val;
    };

    // types/varints/varint64

    if (Long) {

        /**
         * Maximum number of bytes required to store a 64bit base 128 variable-length integer.
         * @type {number}
         * @const
         * @expose
         */
        ByteBuffer.MAX_VARINT64_BYTES = 10;

        /**
         * Calculates the actual number of bytes required to store a 64bit base 128 variable-length integer.
         * @param {number|!Long} value Value to encode
         * @returns {number} Number of bytes required. Capped to {@link ByteBuffer.MAX_VARINT64_BYTES}
         * @expose
         */
        ByteBuffer.calculateVarint64 = function(value) {
            if (typeof value === 'number')
                value = Long.fromNumber(value);
            else if (typeof value === 'string')
                value = Long.fromString(value);
            // ref: src/google/protobuf/io/coded_stream.cc
            var part0 = value.toInt() >>> 0,
                part1 = value.shiftRightUnsigned(28).toInt() >>> 0,
                part2 = value.shiftRightUnsigned(56).toInt() >>> 0;
            if (part2 == 0) {
                if (part1 == 0) {
                    if (part0 < 1 << 14)
                        return part0 < 1 << 7 ? 1 : 2;
                    else
                        return part0 < 1 << 21 ? 3 : 4;
                } else {
                    if (part1 < 1 << 14)
                        return part1 < 1 << 7 ? 5 : 6;
                    else
                        return part1 < 1 << 21 ? 7 : 8;
                }
            } else
                return part2 < 1 << 7 ? 9 : 10;
        };

        /**
         * Zigzag encodes a signed 64bit integer so that it can be effectively used with varint encoding.
         * @param {number|!Long} value Signed long
         * @returns {!Long} Unsigned zigzag encoded long
         * @expose
         */
        ByteBuffer.zigZagEncode64 = function(value) {
            if (typeof value === 'number')
                value = Long.fromNumber(value, false);
            else if (typeof value === 'string')
                value = Long.fromString(value, false);
            else if (value.unsigned !== false) value = value.toSigned();
            // ref: src/google/protobuf/wire_format_lite.h
            return value.shiftLeft(1).xor(value.shiftRight(63)).toUnsigned();
        };

        /**
         * Decodes a zigzag encoded signed 64bit integer.
         * @param {!Long|number} value Unsigned zigzag encoded long or JavaScript number
         * @returns {!Long} Signed long
         * @expose
         */
        ByteBuffer.zigZagDecode64 = function(value) {
            if (typeof value === 'number')
                value = Long.fromNumber(value, false);
            else if (typeof value === 'string')
                value = Long.fromString(value, false);
            else if (value.unsigned !== false) value = value.toSigned();
            // ref: src/google/protobuf/wire_format_lite.h
            return value.shiftRightUnsigned(1).xor(value.and(Long.ONE).toSigned().negate()).toSigned();
        };

        /**
         * Writes a 64bit base 128 variable-length integer.
         * @param {number|Long} value Value to write
         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
         *  written if omitted.
         * @returns {!ByteBuffer|number} `this` if offset is omitted, else the actual number of bytes written.
         * @expose
         */
        ByteBufferPrototype.writeVarint64 = function(value, offset) {
            var relative = typeof offset === 'undefined';
            if (relative) offset = this.offset;
            if (!this.noAssert) {
                if (typeof value === 'number')
                    value = Long.fromNumber(value);
                else if (typeof value === 'string')
                    value = Long.fromString(value);
                else if (!(value && value instanceof Long))
                    throw TypeError("Illegal value: "+value+" (not an integer or Long)");
                if (typeof offset !== 'number' || offset % 1 !== 0)
                    throw TypeError("Illegal offset: "+offset+" (not an integer)");
                offset >>>= 0;
                if (offset < 0 || offset + 0 > this.buffer.byteLength)
                    throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
            }
            if (typeof value === 'number')
                value = Long.fromNumber(value, false);
            else if (typeof value === 'string')
                value = Long.fromString(value, false);
            else if (value.unsigned !== false) value = value.toSigned();
            var size = ByteBuffer.calculateVarint64(value),
                part0 = value.toInt() >>> 0,
                part1 = value.shiftRightUnsigned(28).toInt() >>> 0,
                part2 = value.shiftRightUnsigned(56).toInt() >>> 0;
            offset += size;
            var capacity11 = this.buffer.byteLength;
            if (offset > capacity11)
                this.resize((capacity11 *= 2) > offset ? capacity11 : offset);
            offset -= size;
            switch (size) {
                case 10: this.view[offset+9] = (part2 >>>  7) & 0x01;
                case 9 : this.view[offset+8] = size !== 9 ? (part2       ) | 0x80 : (part2       ) & 0x7F;
                case 8 : this.view[offset+7] = size !== 8 ? (part1 >>> 21) | 0x80 : (part1 >>> 21) & 0x7F;
                case 7 : this.view[offset+6] = size !== 7 ? (part1 >>> 14) | 0x80 : (part1 >>> 14) & 0x7F;
                case 6 : this.view[offset+5] = size !== 6 ? (part1 >>>  7) | 0x80 : (part1 >>>  7) & 0x7F;
                case 5 : this.view[offset+4] = size !== 5 ? (part1       ) | 0x80 : (part1       ) & 0x7F;
                case 4 : this.view[offset+3] = size !== 4 ? (part0 >>> 21) | 0x80 : (part0 >>> 21) & 0x7F;
                case 3 : this.view[offset+2] = size !== 3 ? (part0 >>> 14) | 0x80 : (part0 >>> 14) & 0x7F;
                case 2 : this.view[offset+1] = size !== 2 ? (part0 >>>  7) | 0x80 : (part0 >>>  7) & 0x7F;
                case 1 : this.view[offset  ] = size !== 1 ? (part0       ) | 0x80 : (part0       ) & 0x7F;
            }
            if (relative) {
                this.offset += size;
                return this;
            } else {
                return size;
            }
        };

        /**
         * Writes a zig-zag encoded 64bit base 128 variable-length integer.
         * @param {number|Long} value Value to write
         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
         *  written if omitted.
         * @returns {!ByteBuffer|number} `this` if offset is omitted, else the actual number of bytes written.
         * @expose
         */
        ByteBufferPrototype.writeVarint64ZigZag = function(value, offset) {
            return this.writeVarint64(ByteBuffer.zigZagEncode64(value), offset);
        };

        /**
         * Reads a 64bit base 128 variable-length integer. Requires Long.js.
         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
         *  read if omitted.
         * @returns {!Long|!{value: Long, length: number}} The value read if offset is omitted, else the value read and
         *  the actual number of bytes read.
         * @throws {Error} If it's not a valid varint
         * @expose
         */
        ByteBufferPrototype.readVarint64 = function(offset) {
            var relative = typeof offset === 'undefined';
            if (relative) offset = this.offset;
            if (!this.noAssert) {
                if (typeof offset !== 'number' || offset % 1 !== 0)
                    throw TypeError("Illegal offset: "+offset+" (not an integer)");
                offset >>>= 0;
                if (offset < 0 || offset + 1 > this.buffer.byteLength)
                    throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.byteLength);
            }
            // ref: src/google/protobuf/io/coded_stream.cc
            var start = offset,
                part0 = 0,
                part1 = 0,
                part2 = 0,
                b  = 0;
            b = this.view[offset++]; part0  = (b & 0x7F)      ; if ( b & 0x80                                                   ) {
            b = this.view[offset++]; part0 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
            b = this.view[offset++]; part0 |= (b & 0x7F) << 14; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
            b = this.view[offset++]; part0 |= (b & 0x7F) << 21; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
            b = this.view[offset++]; part1  = (b & 0x7F)      ; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
            b = this.view[offset++]; part1 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
            b = this.view[offset++]; part1 |= (b & 0x7F) << 14; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
            b = this.view[offset++]; part1 |= (b & 0x7F) << 21; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
            b = this.view[offset++]; part2  = (b & 0x7F)      ; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
            b = this.view[offset++]; part2 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
            throw Error("Buffer overrun"); }}}}}}}}}}
            var value = Long.fromBits(part0 | (part1 << 28), (part1 >>> 4) | (part2) << 24, false);
            if (relative) {
                this.offset = offset;
                return value;
            } else {
                return {
                    'value': value,
                    'length': offset-start
                };
            }
        };

        /**
         * Reads a zig-zag encoded 64bit base 128 variable-length integer. Requires Long.js.
         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
         *  read if omitted.
         * @returns {!Long|!{value: Long, length: number}} The value read if offset is omitted, else the value read and
         *  the actual number of bytes read.
         * @throws {Error} If it's not a valid varint
         * @expose
         */
        ByteBufferPrototype.readVarint64ZigZag = function(offset) {
            var val = this.readVarint64(offset);
            if (val && val['value'] instanceof Long)
                val["value"] = ByteBuffer.zigZagDecode64(val["value"]);
            else
                val = ByteBuffer.zigZagDecode64(val);
            return val;
        };

    } // Long


    // types/strings/cstring

    /**
     * Writes a NULL-terminated UTF8 encoded string. For this to work the specified string must not contain any NULL
     *  characters itself.
     * @param {string} str String to write
     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
     *  contained in `str` + 1 if omitted.
     * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written
     * @expose
     */
    ByteBufferPrototype.writeCString = function(str, offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        var i,
            k = str.length;
        if (!this.noAssert) {
            if (typeof str !== 'string')
                throw TypeError("Illegal str: Not a string");
            for (i=0; i<k; ++i) {
                if (str.charCodeAt(i) === 0)
                    throw RangeError("Illegal str: Contains NULL-characters");
            }
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 0 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
        }
        // UTF8 strings do not contain zero bytes in between except for the zero character, so:
        k = utfx.calculateUTF16asUTF8(stringSource(str))[1];
        offset += k+1;
        var capacity12 = this.buffer.byteLength;
        if (offset > capacity12)
            this.resize((capacity12 *= 2) > offset ? capacity12 : offset);
        offset -= k+1;
        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {
            this.view[offset++] = b;
        }.bind(this));
        this.view[offset++] = 0;
        if (relative) {
            this.offset = offset;
            return this;
        }
        return k;
    };

    /**
     * Reads a NULL-terminated UTF8 encoded string. For this to work the string read must not contain any NULL characters
     *  itself.
     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
     *  read if omitted.
     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string
     *  read and the actual number of bytes read.
     * @expose
     */
    ByteBufferPrototype.readCString = function(offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 1 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.byteLength);
        }
        var start = offset,
            temp;
        // UTF8 strings do not contain zero bytes in between except for the zero character itself, so:
        var sd, b = -1;
        utfx.decodeUTF8toUTF16(function() {
            if (b === 0) return null;
            if (offset >= this.limit)
                throw RangeError("Illegal range: Truncated data, "+offset+" < "+this.limit);
            b = this.view[offset++];
            return b === 0 ? null : b;
        }.bind(this), sd = stringDestination(), true);
        if (relative) {
            this.offset = offset;
            return sd();
        } else {
            return {
                "string": sd(),
                "length": offset - start
            };
        }
    };

    // types/strings/istring

    /**
     * Writes a length as uint32 prefixed UTF8 encoded string.
     * @param {string} str String to write
     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
     *  written if omitted.
     * @returns {!ByteBuffer|number} `this` if `offset` is omitted, else the actual number of bytes written
     * @expose
     * @see ByteBuffer#writeVarint32
     */
    ByteBufferPrototype.writeIString = function(str, offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof str !== 'string')
                throw TypeError("Illegal str: Not a string");
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 0 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
        }
        var start = offset,
            k;
        k = utfx.calculateUTF16asUTF8(stringSource(str), this.noAssert)[1];
        offset += 4+k;
        var capacity13 = this.buffer.byteLength;
        if (offset > capacity13)
            this.resize((capacity13 *= 2) > offset ? capacity13 : offset);
        offset -= 4+k;
        if (this.littleEndian) {
            this.view[offset+3] = (k >>> 24) & 0xFF;
            this.view[offset+2] = (k >>> 16) & 0xFF;
            this.view[offset+1] = (k >>>  8) & 0xFF;
            this.view[offset  ] =  k         & 0xFF;
        } else {
            this.view[offset  ] = (k >>> 24) & 0xFF;
            this.view[offset+1] = (k >>> 16) & 0xFF;
            this.view[offset+2] = (k >>>  8) & 0xFF;
            this.view[offset+3] =  k         & 0xFF;
        }
        offset += 4;
        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {
            this.view[offset++] = b;
        }.bind(this));
        if (offset !== start + 4 + k)
            throw RangeError("Illegal range: Truncated data, "+offset+" == "+(offset+4+k));
        if (relative) {
            this.offset = offset;
            return this;
        }
        return offset - start;
    };

    /**
     * Reads a length as uint32 prefixed UTF8 encoded string.
     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
     *  read if omitted.
     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string
     *  read and the actual number of bytes read.
     * @expose
     * @see ByteBuffer#readVarint32
     */
    ByteBufferPrototype.readIString = function(offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 4 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+4+") <= "+this.buffer.byteLength);
        }
        var start = offset;
        var len = this.readUint32(offset);
        var str = this.readUTF8String(len, ByteBuffer.METRICS_BYTES, offset += 4);
        offset += str['length'];
        if (relative) {
            this.offset = offset;
            return str['string'];
        } else {
            return {
                'string': str['string'],
                'length': offset - start
            };
        }
    };

    // types/strings/utf8string

    /**
     * Metrics representing number of UTF8 characters. Evaluates to `c`.
     * @type {string}
     * @const
     * @expose
     */
    ByteBuffer.METRICS_CHARS = 'c';

    /**
     * Metrics representing number of bytes. Evaluates to `b`.
     * @type {string}
     * @const
     * @expose
     */
    ByteBuffer.METRICS_BYTES = 'b';

    /**
     * Writes an UTF8 encoded string.
     * @param {string} str String to write
     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} if omitted.
     * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written.
     * @expose
     */
    ByteBufferPrototype.writeUTF8String = function(str, offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 0 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
        }
        var k;
        var start = offset;
        k = utfx.calculateUTF16asUTF8(stringSource(str))[1];
        offset += k;
        var capacity14 = this.buffer.byteLength;
        if (offset > capacity14)
            this.resize((capacity14 *= 2) > offset ? capacity14 : offset);
        offset -= k;
        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {
            this.view[offset++] = b;
        }.bind(this));
        if (relative) {
            this.offset = offset;
            return this;
        }
        return offset - start;
    };

    /**
     * Writes an UTF8 encoded string. This is an alias of {@link ByteBuffer#writeUTF8String}.
     * @function
     * @param {string} str String to write
     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} if omitted.
     * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written.
     * @expose
     */
    ByteBufferPrototype.writeString = ByteBufferPrototype.writeUTF8String;

    /**
     * Calculates the number of UTF8 characters of a string. JavaScript itself uses UTF-16, so that a string's
     *  `length` property does not reflect its actual UTF8 size if it contains code points larger than 0xFFFF.
     * @param {string} str String to calculate
     * @returns {number} Number of UTF8 characters
     * @expose
     */
    ByteBuffer.calculateUTF8Chars = function(str) {
        return utfx.calculateUTF16asUTF8(stringSource(str))[0];
    };

    /**
     * Calculates the number of UTF8 bytes of a string.
     * @param {string} str String to calculate
     * @returns {number} Number of UTF8 bytes
     * @expose
     */
    ByteBuffer.calculateUTF8Bytes = function(str) {
        return utfx.calculateUTF16asUTF8(stringSource(str))[1];
    };

    /**
     * Calculates the number of UTF8 bytes of a string. This is an alias of {@link ByteBuffer.calculateUTF8Bytes}.
     * @function
     * @param {string} str String to calculate
     * @returns {number} Number of UTF8 bytes
     * @expose
     */
    ByteBuffer.calculateString = ByteBuffer.calculateUTF8Bytes;

    /**
     * Reads an UTF8 encoded string.
     * @param {number} length Number of characters or bytes to read.
     * @param {string=} metrics Metrics specifying what `length` is meant to count. Defaults to
     *  {@link ByteBuffer.METRICS_CHARS}.
     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
     *  read if omitted.
     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string
     *  read and the actual number of bytes read.
     * @expose
     */
    ByteBufferPrototype.readUTF8String = function(length, metrics, offset) {
        if (typeof metrics === 'number') {
            offset = metrics;
            metrics = undefined;
        }
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (typeof metrics === 'undefined') metrics = ByteBuffer.METRICS_CHARS;
        if (!this.noAssert) {
            if (typeof length !== 'number' || length % 1 !== 0)
                throw TypeError("Illegal length: "+length+" (not an integer)");
            length |= 0;
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 0 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
        }
        var i = 0,
            start = offset,
            sd;
        if (metrics === ByteBuffer.METRICS_CHARS) { // The same for node and the browser
            sd = stringDestination();
            utfx.decodeUTF8(function() {
                return i < length && offset < this.limit ? this.view[offset++] : null;
            }.bind(this), function(cp) {
                ++i; utfx.UTF8toUTF16(cp, sd);
            });
            if (i !== length)
                throw RangeError("Illegal range: Truncated data, "+i+" == "+length);
            if (relative) {
                this.offset = offset;
                return sd();
            } else {
                return {
                    "string": sd(),
                    "length": offset - start
                };
            }
        } else if (metrics === ByteBuffer.METRICS_BYTES) {
            if (!this.noAssert) {
                if (typeof offset !== 'number' || offset % 1 !== 0)
                    throw TypeError("Illegal offset: "+offset+" (not an integer)");
                offset >>>= 0;
                if (offset < 0 || offset + length > this.buffer.byteLength)
                    throw RangeError("Illegal offset: 0 <= "+offset+" (+"+length+") <= "+this.buffer.byteLength);
            }
            var k = offset + length;
            utfx.decodeUTF8toUTF16(function() {
                return offset < k ? this.view[offset++] : null;
            }.bind(this), sd = stringDestination(), this.noAssert);
            if (offset !== k)
                throw RangeError("Illegal range: Truncated data, "+offset+" == "+k);
            if (relative) {
                this.offset = offset;
                return sd();
            } else {
                return {
                    'string': sd(),
                    'length': offset - start
                };
            }
        } else
            throw TypeError("Unsupported metrics: "+metrics);
    };

    /**
     * Reads an UTF8 encoded string. This is an alias of {@link ByteBuffer#readUTF8String}.
     * @function
     * @param {number} length Number of characters or bytes to read
     * @param {number=} metrics Metrics specifying what `n` is meant to count. Defaults to
     *  {@link ByteBuffer.METRICS_CHARS}.
     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
     *  read if omitted.
     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string
     *  read and the actual number of bytes read.
     * @expose
     */
    ByteBufferPrototype.readString = ByteBufferPrototype.readUTF8String;

    // types/strings/vstring

    /**
     * Writes a length as varint32 prefixed UTF8 encoded string.
     * @param {string} str String to write
     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
     *  written if omitted.
     * @returns {!ByteBuffer|number} `this` if `offset` is omitted, else the actual number of bytes written
     * @expose
     * @see ByteBuffer#writeVarint32
     */
    ByteBufferPrototype.writeVString = function(str, offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof str !== 'string')
                throw TypeError("Illegal str: Not a string");
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 0 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
        }
        var start = offset,
            k, l;
        k = utfx.calculateUTF16asUTF8(stringSource(str), this.noAssert)[1];
        l = ByteBuffer.calculateVarint32(k);
        offset += l+k;
        var capacity15 = this.buffer.byteLength;
        if (offset > capacity15)
            this.resize((capacity15 *= 2) > offset ? capacity15 : offset);
        offset -= l+k;
        offset += this.writeVarint32(k, offset);
        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {
            this.view[offset++] = b;
        }.bind(this));
        if (offset !== start+k+l)
            throw RangeError("Illegal range: Truncated data, "+offset+" == "+(offset+k+l));
        if (relative) {
            this.offset = offset;
            return this;
        }
        return offset - start;
    };

    /**
     * Reads a length as varint32 prefixed UTF8 encoded string.
     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
     *  read if omitted.
     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string
     *  read and the actual number of bytes read.
     * @expose
     * @see ByteBuffer#readVarint32
     */
    ByteBufferPrototype.readVString = function(offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 1 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.byteLength);
        }
        var start = offset;
        var len = this.readVarint32(offset);
        var str = this.readUTF8String(len['value'], ByteBuffer.METRICS_BYTES, offset += len['length']);
        offset += str['length'];
        if (relative) {
            this.offset = offset;
            return str['string'];
        } else {
            return {
                'string': str['string'],
                'length': offset - start
            };
        }
    };


    /**
     * Appends some data to this ByteBuffer. This will overwrite any contents behind the specified offset up to the appended
     *  data's length.
     * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string} source Data to append. If `source` is a ByteBuffer, its offsets
     *  will be modified according to the performed read operation.
     * @param {(string|number)=} encoding Encoding if `data` is a string ("base64", "hex", "binary", defaults to "utf8")
     * @param {number=} offset Offset to append at. Will use and increase {@link ByteBuffer#offset} by the number of bytes
     *  written if omitted.
     * @returns {!ByteBuffer} this
     * @expose
     * @example A relative `<01 02>03.append(<04 05>)` will result in `<01 02 04 05>, 04 05|`
     * @example An absolute `<01 02>03.append(04 05>, 1)` will result in `<01 04>05, 04 05|`
     */
    ByteBufferPrototype.append = function(source, encoding, offset) {
        if (typeof encoding === 'number' || typeof encoding !== 'string') {
            offset = encoding;
            encoding = undefined;
        }
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 0 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
        }
        if (!(source instanceof ByteBuffer))
            source = ByteBuffer.wrap(source, encoding);
        var length = source.limit - source.offset;
        if (length <= 0) return this; // Nothing to append
        offset += length;
        var capacity16 = this.buffer.byteLength;
        if (offset > capacity16)
            this.resize((capacity16 *= 2) > offset ? capacity16 : offset);
        offset -= length;
        this.view.set(source.view.subarray(source.offset, source.limit), offset);
        source.offset += length;
        if (relative) this.offset += length;
        return this;
    };

    /**
     * Appends this ByteBuffer's contents to another ByteBuffer. This will overwrite any contents at and after the
        specified offset up to the length of this ByteBuffer's data.
     * @param {!ByteBuffer} target Target ByteBuffer
     * @param {number=} offset Offset to append to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
     *  read if omitted.
     * @returns {!ByteBuffer} this
     * @expose
     * @see ByteBuffer#append
     */
    ByteBufferPrototype.appendTo = function(target, offset) {
        target.append(this, offset);
        return this;
    };

    /**
     * Enables or disables assertions of argument types and offsets. Assertions are enabled by default but you can opt to
     *  disable them if your code already makes sure that everything is valid.
     * @param {boolean} assert `true` to enable assertions, otherwise `false`
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.assert = function(assert) {
        this.noAssert = !assert;
        return this;
    };

    /**
     * Gets the capacity of this ByteBuffer's backing buffer.
     * @returns {number} Capacity of the backing buffer
     * @expose
     */
    ByteBufferPrototype.capacity = function() {
        return this.buffer.byteLength;
    };
    /**
     * Clears this ByteBuffer's offsets by setting {@link ByteBuffer#offset} to `0` and {@link ByteBuffer#limit} to the
     *  backing buffer's capacity. Discards {@link ByteBuffer#markedOffset}.
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.clear = function() {
        this.offset = 0;
        this.limit = this.buffer.byteLength;
        this.markedOffset = -1;
        return this;
    };

    /**
     * Creates a cloned instance of this ByteBuffer, preset with this ByteBuffer's values for {@link ByteBuffer#offset},
     *  {@link ByteBuffer#markedOffset} and {@link ByteBuffer#limit}.
     * @param {boolean=} copy Whether to copy the backing buffer or to return another view on the same, defaults to `false`
     * @returns {!ByteBuffer} Cloned instance
     * @expose
     */
    ByteBufferPrototype.clone = function(copy) {
        var bb = new ByteBuffer(0, this.littleEndian, this.noAssert);
        if (copy) {
            bb.buffer = new ArrayBuffer(this.buffer.byteLength);
            bb.view = new Uint8Array(bb.buffer);
        } else {
            bb.buffer = this.buffer;
            bb.view = this.view;
        }
        bb.offset = this.offset;
        bb.markedOffset = this.markedOffset;
        bb.limit = this.limit;
        return bb;
    };

    /**
     * Compacts this ByteBuffer to be backed by a {@link ByteBuffer#buffer} of its contents' length. Contents are the bytes
     *  between {@link ByteBuffer#offset} and {@link ByteBuffer#limit}. Will set `offset = 0` and `limit = capacity` and
     *  adapt {@link ByteBuffer#markedOffset} to the same relative position if set.
     * @param {number=} begin Offset to start at, defaults to {@link ByteBuffer#offset}
     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.compact = function(begin, end) {
        if (typeof begin === 'undefined') begin = this.offset;
        if (typeof end === 'undefined') end = this.limit;
        if (!this.noAssert) {
            if (typeof begin !== 'number' || begin % 1 !== 0)
                throw TypeError("Illegal begin: Not an integer");
            begin >>>= 0;
            if (typeof end !== 'number' || end % 1 !== 0)
                throw TypeError("Illegal end: Not an integer");
            end >>>= 0;
            if (begin < 0 || begin > end || end > this.buffer.byteLength)
                throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.byteLength);
        }
        if (begin === 0 && end === this.buffer.byteLength)
            return this; // Already compacted
        var len = end - begin;
        if (len === 0) {
            this.buffer = EMPTY_BUFFER;
            this.view = null;
            if (this.markedOffset >= 0) this.markedOffset -= begin;
            this.offset = 0;
            this.limit = 0;
            return this;
        }
        var buffer = new ArrayBuffer(len);
        var view = new Uint8Array(buffer);
        view.set(this.view.subarray(begin, end));
        this.buffer = buffer;
        this.view = view;
        if (this.markedOffset >= 0) this.markedOffset -= begin;
        this.offset = 0;
        this.limit = len;
        return this;
    };

    /**
     * Creates a copy of this ByteBuffer's contents. Contents are the bytes between {@link ByteBuffer#offset} and
     *  {@link ByteBuffer#limit}.
     * @param {number=} begin Begin offset, defaults to {@link ByteBuffer#offset}.
     * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.
     * @returns {!ByteBuffer} Copy
     * @expose
     */
    ByteBufferPrototype.copy = function(begin, end) {
        if (typeof begin === 'undefined') begin = this.offset;
        if (typeof end === 'undefined') end = this.limit;
        if (!this.noAssert) {
            if (typeof begin !== 'number' || begin % 1 !== 0)
                throw TypeError("Illegal begin: Not an integer");
            begin >>>= 0;
            if (typeof end !== 'number' || end % 1 !== 0)
                throw TypeError("Illegal end: Not an integer");
            end >>>= 0;
            if (begin < 0 || begin > end || end > this.buffer.byteLength)
                throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.byteLength);
        }
        if (begin === end)
            return new ByteBuffer(0, this.littleEndian, this.noAssert);
        var capacity = end - begin,
            bb = new ByteBuffer(capacity, this.littleEndian, this.noAssert);
        bb.offset = 0;
        bb.limit = capacity;
        if (bb.markedOffset >= 0) bb.markedOffset -= begin;
        this.copyTo(bb, 0, begin, end);
        return bb;
    };

    /**
     * Copies this ByteBuffer's contents to another ByteBuffer. Contents are the bytes between {@link ByteBuffer#offset} and
     *  {@link ByteBuffer#limit}.
     * @param {!ByteBuffer} target Target ByteBuffer
     * @param {number=} targetOffset Offset to copy to. Will use and increase the target's {@link ByteBuffer#offset}
     *  by the number of bytes copied if omitted.
     * @param {number=} sourceOffset Offset to start copying from. Will use and increase {@link ByteBuffer#offset} by the
     *  number of bytes copied if omitted.
     * @param {number=} sourceLimit Offset to end copying from, defaults to {@link ByteBuffer#limit}
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.copyTo = function(target, targetOffset, sourceOffset, sourceLimit) {
        var relative,
            targetRelative;
        if (!this.noAssert) {
            if (!ByteBuffer.isByteBuffer(target))
                throw TypeError("Illegal target: Not a ByteBuffer");
        }
        targetOffset = (targetRelative = typeof targetOffset === 'undefined') ? target.offset : targetOffset | 0;
        sourceOffset = (relative = typeof sourceOffset === 'undefined') ? this.offset : sourceOffset | 0;
        sourceLimit = typeof sourceLimit === 'undefined' ? this.limit : sourceLimit | 0;

        if (targetOffset < 0 || targetOffset > target.buffer.byteLength)
            throw RangeError("Illegal target range: 0 <= "+targetOffset+" <= "+target.buffer.byteLength);
        if (sourceOffset < 0 || sourceLimit > this.buffer.byteLength)
            throw RangeError("Illegal source range: 0 <= "+sourceOffset+" <= "+this.buffer.byteLength);

        var len = sourceLimit - sourceOffset;
        if (len === 0)
            return target; // Nothing to copy

        target.ensureCapacity(targetOffset + len);

        target.view.set(this.view.subarray(sourceOffset, sourceLimit), targetOffset);

        if (relative) this.offset += len;
        if (targetRelative) target.offset += len;

        return this;
    };

    /**
     * Makes sure that this ByteBuffer is backed by a {@link ByteBuffer#buffer} of at least the specified capacity. If the
     *  current capacity is exceeded, it will be doubled. If double the current capacity is less than the required capacity,
     *  the required capacity will be used instead.
     * @param {number} capacity Required capacity
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.ensureCapacity = function(capacity) {
        var current = this.buffer.byteLength;
        if (current < capacity)
            return this.resize((current *= 2) > capacity ? current : capacity);
        return this;
    };

    /**
     * Overwrites this ByteBuffer's contents with the specified value. Contents are the bytes between
     *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}.
     * @param {number|string} value Byte value to fill with. If given as a string, the first character is used.
     * @param {number=} begin Begin offset. Will use and increase {@link ByteBuffer#offset} by the number of bytes
     *  written if omitted. defaults to {@link ByteBuffer#offset}.
     * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.
     * @returns {!ByteBuffer} this
     * @expose
     * @example `someByteBuffer.clear().fill(0)` fills the entire backing buffer with zeroes
     */
    ByteBufferPrototype.fill = function(value, begin, end) {
        var relative = typeof begin === 'undefined';
        if (relative) begin = this.offset;
        if (typeof value === 'string' && value.length > 0)
            value = value.charCodeAt(0);
        if (typeof begin === 'undefined') begin = this.offset;
        if (typeof end === 'undefined') end = this.limit;
        if (!this.noAssert) {
            if (typeof value !== 'number' || value % 1 !== 0)
                throw TypeError("Illegal value: "+value+" (not an integer)");
            value |= 0;
            if (typeof begin !== 'number' || begin % 1 !== 0)
                throw TypeError("Illegal begin: Not an integer");
            begin >>>= 0;
            if (typeof end !== 'number' || end % 1 !== 0)
                throw TypeError("Illegal end: Not an integer");
            end >>>= 0;
            if (begin < 0 || begin > end || end > this.buffer.byteLength)
                throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.byteLength);
        }
        if (begin >= end)
            return this; // Nothing to fill
        while (begin < end) this.view[begin++] = value;
        if (relative) this.offset = begin;
        return this;
    };

    /**
     * Makes this ByteBuffer ready for a new sequence of write or relative read operations. Sets `limit = offset` and
     *  `offset = 0`. Make sure always to flip a ByteBuffer when all relative read or write operations are complete.
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.flip = function() {
        this.limit = this.offset;
        this.offset = 0;
        return this;
    };
    /**
     * Marks an offset on this ByteBuffer to be used later.
     * @param {number=} offset Offset to mark. Defaults to {@link ByteBuffer#offset}.
     * @returns {!ByteBuffer} this
     * @throws {TypeError} If `offset` is not a valid number
     * @throws {RangeError} If `offset` is out of bounds
     * @see ByteBuffer#reset
     * @expose
     */
    ByteBufferPrototype.mark = function(offset) {
        offset = typeof offset === 'undefined' ? this.offset : offset;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 0 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
        }
        this.markedOffset = offset;
        return this;
    };
    /**
     * Sets the byte order.
     * @param {boolean} littleEndian `true` for little endian byte order, `false` for big endian
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.order = function(littleEndian) {
        if (!this.noAssert) {
            if (typeof littleEndian !== 'boolean')
                throw TypeError("Illegal littleEndian: Not a boolean");
        }
        this.littleEndian = !!littleEndian;
        return this;
    };

    /**
     * Switches (to) little endian byte order.
     * @param {boolean=} littleEndian Defaults to `true`, otherwise uses big endian
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.LE = function(littleEndian) {
        this.littleEndian = typeof littleEndian !== 'undefined' ? !!littleEndian : true;
        return this;
    };

    /**
     * Switches (to) big endian byte order.
     * @param {boolean=} bigEndian Defaults to `true`, otherwise uses little endian
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.BE = function(bigEndian) {
        this.littleEndian = typeof bigEndian !== 'undefined' ? !bigEndian : false;
        return this;
    };
    /**
     * Prepends some data to this ByteBuffer. This will overwrite any contents before the specified offset up to the
     *  prepended data's length. If there is not enough space available before the specified `offset`, the backing buffer
     *  will be resized and its contents moved accordingly.
     * @param {!ByteBuffer|string|!ArrayBuffer} source Data to prepend. If `source` is a ByteBuffer, its offset will be
     *  modified according to the performed read operation.
     * @param {(string|number)=} encoding Encoding if `data` is a string ("base64", "hex", "binary", defaults to "utf8")
     * @param {number=} offset Offset to prepend at. Will use and decrease {@link ByteBuffer#offset} by the number of bytes
     *  prepended if omitted.
     * @returns {!ByteBuffer} this
     * @expose
     * @example A relative `00<01 02 03>.prepend(<04 05>)` results in `<04 05 01 02 03>, 04 05|`
     * @example An absolute `00<01 02 03>.prepend(<04 05>, 2)` results in `04<05 02 03>, 04 05|`
     */
    ByteBufferPrototype.prepend = function(source, encoding, offset) {
        if (typeof encoding === 'number' || typeof encoding !== 'string') {
            offset = encoding;
            encoding = undefined;
        }
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: "+offset+" (not an integer)");
            offset >>>= 0;
            if (offset < 0 || offset + 0 > this.buffer.byteLength)
                throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.byteLength);
        }
        if (!(source instanceof ByteBuffer))
            source = ByteBuffer.wrap(source, encoding);
        var len = source.limit - source.offset;
        if (len <= 0) return this; // Nothing to prepend
        var diff = len - offset;
        if (diff > 0) { // Not enough space before offset, so resize + move
            var buffer = new ArrayBuffer(this.buffer.byteLength + diff);
            var view = new Uint8Array(buffer);
            view.set(this.view.subarray(offset, this.buffer.byteLength), len);
            this.buffer = buffer;
            this.view = view;
            this.offset += diff;
            if (this.markedOffset >= 0) this.markedOffset += diff;
            this.limit += diff;
            offset += diff;
        } else {
            var arrayView = new Uint8Array(this.buffer);
        }
        this.view.set(source.view.subarray(source.offset, source.limit), offset - len);

        source.offset = source.limit;
        if (relative)
            this.offset -= len;
        return this;
    };

    /**
     * Prepends this ByteBuffer to another ByteBuffer. This will overwrite any contents before the specified offset up to the
     *  prepended data's length. If there is not enough space available before the specified `offset`, the backing buffer
     *  will be resized and its contents moved accordingly.
     * @param {!ByteBuffer} target Target ByteBuffer
     * @param {number=} offset Offset to prepend at. Will use and decrease {@link ByteBuffer#offset} by the number of bytes
     *  prepended if omitted.
     * @returns {!ByteBuffer} this
     * @expose
     * @see ByteBuffer#prepend
     */
    ByteBufferPrototype.prependTo = function(target, offset) {
        target.prepend(this, offset);
        return this;
    };
    /**
     * Prints debug information about this ByteBuffer's contents.
     * @param {function(string)=} out Output function to call, defaults to console.log
     * @expose
     */
    ByteBufferPrototype.printDebug = function(out) {
        if (typeof out !== 'function') out = console.log.bind(console);
        out(
            this.toString()+"\n"+
            "-------------------------------------------------------------------\n"+
            this.toDebug(/* columns */ true)
        );
    };

    /**
     * Gets the number of remaining readable bytes. Contents are the bytes between {@link ByteBuffer#offset} and
     *  {@link ByteBuffer#limit}, so this returns `limit - offset`.
     * @returns {number} Remaining readable bytes. May be negative if `offset > limit`.
     * @expose
     */
    ByteBufferPrototype.remaining = function() {
        return this.limit - this.offset;
    };
    /**
     * Resets this ByteBuffer's {@link ByteBuffer#offset}. If an offset has been marked through {@link ByteBuffer#mark}
     *  before, `offset` will be set to {@link ByteBuffer#markedOffset}, which will then be discarded. If no offset has been
     *  marked, sets `offset = 0`.
     * @returns {!ByteBuffer} this
     * @see ByteBuffer#mark
     * @expose
     */
    ByteBufferPrototype.reset = function() {
        if (this.markedOffset >= 0) {
            this.offset = this.markedOffset;
            this.markedOffset = -1;
        } else {
            this.offset = 0;
        }
        return this;
    };
    /**
     * Resizes this ByteBuffer to be backed by a buffer of at least the given capacity. Will do nothing if already that
     *  large or larger.
     * @param {number} capacity Capacity required
     * @returns {!ByteBuffer} this
     * @throws {TypeError} If `capacity` is not a number
     * @throws {RangeError} If `capacity < 0`
     * @expose
     */
    ByteBufferPrototype.resize = function(capacity) {
        if (!this.noAssert) {
            if (typeof capacity !== 'number' || capacity % 1 !== 0)
                throw TypeError("Illegal capacity: "+capacity+" (not an integer)");
            capacity |= 0;
            if (capacity < 0)
                throw RangeError("Illegal capacity: 0 <= "+capacity);
        }
        if (this.buffer.byteLength < capacity) {
            var buffer = new ArrayBuffer(capacity);
            var view = new Uint8Array(buffer);
            view.set(this.view);
            this.buffer = buffer;
            this.view = view;
        }
        return this;
    };
    /**
     * Reverses this ByteBuffer's contents.
     * @param {number=} begin Offset to start at, defaults to {@link ByteBuffer#offset}
     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.reverse = function(begin, end) {
        if (typeof begin === 'undefined') begin = this.offset;
        if (typeof end === 'undefined') end = this.limit;
        if (!this.noAssert) {
            if (typeof begin !== 'number' || begin % 1 !== 0)
                throw TypeError("Illegal begin: Not an integer");
            begin >>>= 0;
            if (typeof end !== 'number' || end % 1 !== 0)
                throw TypeError("Illegal end: Not an integer");
            end >>>= 0;
            if (begin < 0 || begin > end || end > this.buffer.byteLength)
                throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.byteLength);
        }
        if (begin === end)
            return this; // Nothing to reverse
        Array.prototype.reverse.call(this.view.subarray(begin, end));
        return this;
    };
    /**
     * Skips the next `length` bytes. This will just advance
     * @param {number} length Number of bytes to skip. May also be negative to move the offset back.
     * @returns {!ByteBuffer} this
     * @expose
     */
    ByteBufferPrototype.skip = function(length) {
        if (!this.noAssert) {
            if (typeof length !== 'number' || length % 1 !== 0)
                throw TypeError("Illegal length: "+length+" (not an integer)");
            length |= 0;
        }
        var offset = this.offset + length;
        if (!this.noAssert) {
            if (offset < 0 || offset > this.buffer.byteLength)
                throw RangeError("Illegal length: 0 <= "+this.offset+" + "+length+" <= "+this.buffer.byteLength);
        }
        this.offset = offset;
        return this;
    };

    /**
     * Slices this ByteBuffer by creating a cloned instance with `offset = begin` and `limit = end`.
     * @param {number=} begin Begin offset, defaults to {@link ByteBuffer#offset}.
     * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.
     * @returns {!ByteBuffer} Clone of this ByteBuffer with slicing applied, backed by the same {@link ByteBuffer#buffer}
     * @expose
     */
    ByteBufferPrototype.slice = function(begin, end) {
        if (typeof begin === 'undefined') begin = this.offset;
        if (typeof end === 'undefined') end = this.limit;
        if (!this.noAssert) {
            if (typeof begin !== 'number' || begin % 1 !== 0)
                throw TypeError("Illegal begin: Not an integer");
            begin >>>= 0;
            if (typeof end !== 'number' || end % 1 !== 0)
                throw TypeError("Illegal end: Not an integer");
            end >>>= 0;
            if (begin < 0 || begin > end || end > this.buffer.byteLength)
                throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.byteLength);
        }
        var bb = this.clone();
        bb.offset = begin;
        bb.limit = end;
        return bb;
    };
    /**
     * Returns a copy of the backing buffer that contains this ByteBuffer's contents. Contents are the bytes between
     *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}.
     * @param {boolean=} forceCopy If `true` returns a copy, otherwise returns a view referencing the same memory if
     *  possible. Defaults to `false`
     * @returns {!ArrayBuffer} Contents as an ArrayBuffer
     * @expose
     */
    ByteBufferPrototype.toBuffer = function(forceCopy) {
        var offset = this.offset,
            limit = this.limit;
        if (!this.noAssert) {
            if (typeof offset !== 'number' || offset % 1 !== 0)
                throw TypeError("Illegal offset: Not an integer");
            offset >>>= 0;
            if (typeof limit !== 'number' || limit % 1 !== 0)
                throw TypeError("Illegal limit: Not an integer");
            limit >>>= 0;
            if (offset < 0 || offset > limit || limit > this.buffer.byteLength)
                throw RangeError("Illegal range: 0 <= "+offset+" <= "+limit+" <= "+this.buffer.byteLength);
        }
        // NOTE: It's not possible to have another ArrayBuffer reference the same memory as the backing buffer. This is
        // possible with Uint8Array#subarray only, but we have to return an ArrayBuffer by contract. So:
        if (!forceCopy && offset === 0 && limit === this.buffer.byteLength)
            return this.buffer;
        if (offset === limit)
            return EMPTY_BUFFER;
        var buffer = new ArrayBuffer(limit - offset);
        new Uint8Array(buffer).set(new Uint8Array(this.buffer).subarray(offset, limit), 0);
        return buffer;
    };

    /**
     * Returns a raw buffer compacted to contain this ByteBuffer's contents. Contents are the bytes between
     *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}. This is an alias of {@link ByteBuffer#toBuffer}.
     * @function
     * @param {boolean=} forceCopy If `true` returns a copy, otherwise returns a view referencing the same memory.
     *  Defaults to `false`
     * @returns {!ArrayBuffer} Contents as an ArrayBuffer
     * @expose
     */
    ByteBufferPrototype.toArrayBuffer = ByteBufferPrototype.toBuffer;

    /**
     * Converts the ByteBuffer's contents to a string.
     * @param {string=} encoding Output encoding. Returns an informative string representation if omitted but also allows
     *  direct conversion to "utf8", "hex", "base64" and "binary" encoding. "debug" returns a hex representation with
     *  highlighted offsets.
     * @param {number=} begin Offset to begin at, defaults to {@link ByteBuffer#offset}
     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}
     * @returns {string} String representation
     * @throws {Error} If `encoding` is invalid
     * @expose
     */
    ByteBufferPrototype.toString = function(encoding, begin, end) {
        if (typeof encoding === 'undefined')
            return "ByteBufferAB(offset="+this.offset+",markedOffset="+this.markedOffset+",limit="+this.limit+",capacity="+this.capacity()+")";
        if (typeof encoding === 'number')
            encoding = "utf8",
            begin = encoding,
            end = begin;
        switch (encoding) {
            case "utf8":
                return this.toUTF8(begin, end);
            case "base64":
                return this.toBase64(begin, end);
            case "hex":
                return this.toHex(begin, end);
            case "binary":
                return this.toBinary(begin, end);
            case "debug":
                return this.toDebug();
            case "columns":
                return this.toColumns();
            default:
                throw Error("Unsupported encoding: "+encoding);
        }
    };

    // lxiv-embeddable

    /**
     * lxiv-embeddable (c) 2014 Daniel Wirtz <dcode@dcode.io>
     * Released under the Apache License, Version 2.0
     * see: https://github.com/dcodeIO/lxiv for details
     */
    var lxiv = function() {
        "use strict";

        /**
         * lxiv namespace.
         * @type {!Object.<string,*>}
         * @exports lxiv
         */
        var lxiv = {};

        /**
         * Character codes for output.
         * @type {!Array.<number>}
         * @inner
         */
        var aout = [
            65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
            81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102,
            103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,
            119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47
        ];

        /**
         * Character codes for input.
         * @type {!Array.<number>}
         * @inner
         */
        var ain = [];
        for (var i=0, k=aout.length; i<k; ++i)
            ain[aout[i]] = i;

        /**
         * Encodes bytes to base64 char codes.
         * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if
         *  there are no more bytes left.
         * @param {!function(number)} dst Characters destination as a function successively called with each encoded char
         *  code.
         */
        lxiv.encode = function(src, dst) {
            var b, t;
            while ((b = src()) !== null) {
                dst(aout[(b>>2)&0x3f]);
                t = (b&0x3)<<4;
                if ((b = src()) !== null) {
                    t |= (b>>4)&0xf;
                    dst(aout[(t|((b>>4)&0xf))&0x3f]);
                    t = (b&0xf)<<2;
                    if ((b = src()) !== null)
                        dst(aout[(t|((b>>6)&0x3))&0x3f]),
                        dst(aout[b&0x3f]);
                    else
                        dst(aout[t&0x3f]),
                        dst(61);
                } else
                    dst(aout[t&0x3f]),
                    dst(61),
                    dst(61);
            }
        };

        /**
         * Decodes base64 char codes to bytes.
         * @param {!function():number|null} src Characters source as a function returning the next char code respectively
         *  `null` if there are no more characters left.
         * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.
         * @throws {Error} If a character code is invalid
         */
        lxiv.decode = function(src, dst) {
            var c, t1, t2;
            function fail(c) {
                throw Error("Illegal character code: "+c);
            }
            while ((c = src()) !== null) {
                t1 = ain[c];
                if (typeof t1 === 'undefined') fail(c);
                if ((c = src()) !== null) {
                    t2 = ain[c];
                    if (typeof t2 === 'undefined') fail(c);
                    dst((t1<<2)>>>0|(t2&0x30)>>4);
                    if ((c = src()) !== null) {
                        t1 = ain[c];
                        if (typeof t1 === 'undefined')
                            if (c === 61) break; else fail(c);
                        dst(((t2&0xf)<<4)>>>0|(t1&0x3c)>>2);
                        if ((c = src()) !== null) {
                            t2 = ain[c];
                            if (typeof t2 === 'undefined')
                                if (c === 61) break; else fail(c);
                            dst(((t1&0x3)<<6)>>>0|t2);
                        }
                    }
                }
            }
        };

        /**
         * Tests if a string is valid base64.
         * @param {string} str String to test
         * @returns {boolean} `true` if valid, otherwise `false`
         */
        lxiv.test = function(str) {
            return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(str);
        };

        return lxiv;
    }();

    // encodings/base64

    /**
     * Encodes this ByteBuffer's contents to a base64 encoded string.
     * @param {number=} begin Offset to begin at, defaults to {@link ByteBuffer#offset}.
     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}.
     * @returns {string} Base64 encoded string
     * @throws {RangeError} If `begin` or `end` is out of bounds
     * @expose
     */
    ByteBufferPrototype.toBase64 = function(begin, end) {
        if (typeof begin === 'undefined')
            begin = this.offset;
        if (typeof end === 'undefined')
            end = this.limit;
        begin = begin | 0; end = end | 0;
        if (begin < 0 || end > this.capacity || begin > end)
            throw RangeError("begin, end");
        var sd; lxiv.encode(function() {
            return begin < end ? this.view[begin++] : null;
        }.bind(this), sd = stringDestination());
        return sd();
    };

    /**
     * Decodes a base64 encoded string to a ByteBuffer.
     * @param {string} str String to decode
     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
     *  {@link ByteBuffer.DEFAULT_ENDIAN}.
     * @returns {!ByteBuffer} ByteBuffer
     * @expose
     */
    ByteBuffer.fromBase64 = function(str, littleEndian) {
        if (typeof str !== 'string')
            throw TypeError("str");
        var bb = new ByteBuffer(str.length/4*3, littleEndian),
            i = 0;
        lxiv.decode(stringSource(str), function(b) {
            bb.view[i++] = b;
        });
        bb.limit = i;
        return bb;
    };

    /**
     * Encodes a binary string to base64 like `window.btoa` does.
     * @param {string} str Binary string
     * @returns {string} Base64 encoded string
     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.btoa
     * @expose
     */
    ByteBuffer.btoa = function(str) {
        return ByteBuffer.fromBinary(str).toBase64();
    };

    /**
     * Decodes a base64 encoded string to binary like `window.atob` does.
     * @param {string} b64 Base64 encoded string
     * @returns {string} Binary string
     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.atob
     * @expose
     */
    ByteBuffer.atob = function(b64) {
        return ByteBuffer.fromBase64(b64).toBinary();
    };

    // encodings/binary

    /**
     * Encodes this ByteBuffer to a binary encoded string, that is using only characters 0x00-0xFF as bytes.
     * @param {number=} begin Offset to begin at. Defaults to {@link ByteBuffer#offset}.
     * @param {number=} end Offset to end at. Defaults to {@link ByteBuffer#limit}.
     * @returns {string} Binary encoded string
     * @throws {RangeError} If `offset > limit`
     * @expose
     */
    ByteBufferPrototype.toBinary = function(begin, end) {
        if (typeof begin === 'undefined')
            begin = this.offset;
        if (typeof end === 'undefined')
            end = this.limit;
        begin |= 0; end |= 0;
        if (begin < 0 || end > this.capacity() || begin > end)
            throw RangeError("begin, end");
        if (begin === end)
            return "";
        var chars = [],
            parts = [];
        while (begin < end) {
            chars.push(this.view[begin++]);
            if (chars.length >= 1024)
                parts.push(String.fromCharCode.apply(String, chars)),
                chars = [];
        }
        return parts.join('') + String.fromCharCode.apply(String, chars);
    };

    /**
     * Decodes a binary encoded string, that is using only characters 0x00-0xFF as bytes, to a ByteBuffer.
     * @param {string} str String to decode
     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
     *  {@link ByteBuffer.DEFAULT_ENDIAN}.
     * @returns {!ByteBuffer} ByteBuffer
     * @expose
     */
    ByteBuffer.fromBinary = function(str, littleEndian) {
        if (typeof str !== 'string')
            throw TypeError("str");
        var i = 0,
            k = str.length,
            charCode,
            bb = new ByteBuffer(k, littleEndian);
        while (i<k) {
            charCode = str.charCodeAt(i);
            if (charCode > 0xff)
                throw RangeError("illegal char code: "+charCode);
            bb.view[i++] = charCode;
        }
        bb.limit = k;
        return bb;
    };

    // encodings/debug

    /**
     * Encodes this ByteBuffer to a hex encoded string with marked offsets. Offset symbols are:
     * * `<` : offset,
     * * `'` : markedOffset,
     * * `>` : limit,
     * * `|` : offset and limit,
     * * `[` : offset and markedOffset,
     * * `]` : markedOffset and limit,
     * * `!` : offset, markedOffset and limit
     * @param {boolean=} columns If `true` returns two columns hex + ascii, defaults to `false`
     * @returns {string|!Array.<string>} Debug string or array of lines if `asArray = true`
     * @expose
     * @example `>00'01 02<03` contains four bytes with `limit=0, markedOffset=1, offset=3`
     * @example `00[01 02 03>` contains four bytes with `offset=markedOffset=1, limit=4`
     * @example `00|01 02 03` contains four bytes with `offset=limit=1, markedOffset=-1`
     * @example `|` contains zero bytes with `offset=limit=0, markedOffset=-1`
     */
    ByteBufferPrototype.toDebug = function(columns) {
        var i = -1,
            k = this.buffer.byteLength,
            b,
            hex = "",
            asc = "",
            out = "";
        while (i<k) {
            if (i !== -1) {
                b = this.view[i];
                if (b < 0x10) hex += "0"+b.toString(16).toUpperCase();
                else hex += b.toString(16).toUpperCase();
                if (columns)
                    asc += b > 32 && b < 127 ? String.fromCharCode(b) : '.';
            }
            ++i;
            if (columns) {
                if (i > 0 && i % 16 === 0 && i !== k) {
                    while (hex.length < 3*16+3) hex += " ";
                    out += hex+asc+"\n";
                    hex = asc = "";
                }
            }
            if (i === this.offset && i === this.limit)
                hex += i === this.markedOffset ? "!" : "|";
            else if (i === this.offset)
                hex += i === this.markedOffset ? "[" : "<";
            else if (i === this.limit)
                hex += i === this.markedOffset ? "]" : ">";
            else
                hex += i === this.markedOffset ? "'" : (columns || (i !== 0 && i !== k) ? " " : "");
        }
        if (columns && hex !== " ") {
            while (hex.length < 3*16+3)
                hex += " ";
            out += hex + asc + "\n";
        }
        return columns ? out : hex;
    };

    /**
     * Decodes a hex encoded string with marked offsets to a ByteBuffer.
     * @param {string} str Debug string to decode (not be generated with `columns = true`)
     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
     *  {@link ByteBuffer.DEFAULT_ENDIAN}.
     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to
     *  {@link ByteBuffer.DEFAULT_NOASSERT}.
     * @returns {!ByteBuffer} ByteBuffer
     * @expose
     * @see ByteBuffer#toDebug
     */
    ByteBuffer.fromDebug = function(str, littleEndian, noAssert) {
        var k = str.length,
            bb = new ByteBuffer(((k+1)/3)|0, littleEndian, noAssert);
        var i = 0, j = 0, ch, b,
            rs = false, // Require symbol next
            ho = false, hm = false, hl = false, // Already has offset (ho), markedOffset (hm), limit (hl)?
            fail = false;
        while (i<k) {
            switch (ch = str.charAt(i++)) {
                case '!':
                    if (!noAssert) {
                        if (ho || hm || hl) {
                            fail = true;
                            break;
                        }
                        ho = hm = hl = true;
                    }
                    bb.offset = bb.markedOffset = bb.limit = j;
                    rs = false;
                    break;
                case '|':
                    if (!noAssert) {
                        if (ho || hl) {
                            fail = true;
                            break;
                        }
                        ho = hl = true;
                    }
                    bb.offset = bb.limit = j;
                    rs = false;
                    break;
                case '[':
                    if (!noAssert) {
                        if (ho || hm) {
                            fail = true;
                            break;
                        }
                        ho = hm = true;
                    }
                    bb.offset = bb.markedOffset = j;
                    rs = false;
                    break;
                case '<':
                    if (!noAssert) {
                        if (ho) {
                            fail = true;
                            break;
                        }
                        ho = true;
                    }
                    bb.offset = j;
                    rs = false;
                    break;
                case ']':
                    if (!noAssert) {
                        if (hl || hm) {
                            fail = true;
                            break;
                        }
                        hl = hm = true;
                    }
                    bb.limit = bb.markedOffset = j;
                    rs = false;
                    break;
                case '>':
                    if (!noAssert) {
                        if (hl) {
                            fail = true;
                            break;
                        }
                        hl = true;
                    }
                    bb.limit = j;
                    rs = false;
                    break;
                case "'":
                    if (!noAssert) {
                        if (hm) {
                            fail = true;
                            break;
                        }
                        hm = true;
                    }
                    bb.markedOffset = j;
                    rs = false;
                    break;
                case ' ':
                    rs = false;
                    break;
                default:
                    if (!noAssert) {
                        if (rs) {
                            fail = true;
                            break;
                        }
                    }
                    b = parseInt(ch+str.charAt(i++), 16);
                    if (!noAssert) {
                        if (isNaN(b) || b < 0 || b > 255)
                            throw TypeError("Illegal str: Not a debug encoded string");
                    }
                    bb.view[j++] = b;
                    rs = true;
            }
            if (fail)
                throw TypeError("Illegal str: Invalid symbol at "+i);
        }
        if (!noAssert) {
            if (!ho || !hl)
                throw TypeError("Illegal str: Missing offset or limit");
            if (j<bb.buffer.byteLength)
                throw TypeError("Illegal str: Not a debug encoded string (is it hex?) "+j+" < "+k);
        }
        return bb;
    };

    // encodings/hex

    /**
     * Encodes this ByteBuffer's contents to a hex encoded string.
     * @param {number=} begin Offset to begin at. Defaults to {@link ByteBuffer#offset}.
     * @param {number=} end Offset to end at. Defaults to {@link ByteBuffer#limit}.
     * @returns {string} Hex encoded string
     * @expose
     */
    ByteBufferPrototype.toHex = function(begin, end) {
        begin = typeof begin === 'undefined' ? this.offset : begin;
        end = typeof end === 'undefined' ? this.limit : end;
        if (!this.noAssert) {
            if (typeof begin !== 'number' || begin % 1 !== 0)
                throw TypeError("Illegal begin: Not an integer");
            begin >>>= 0;
            if (typeof end !== 'number' || end % 1 !== 0)
                throw TypeError("Illegal end: Not an integer");
            end >>>= 0;
            if (begin < 0 || begin > end || end > this.buffer.byteLength)
                throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.byteLength);
        }
        var out = new Array(end - begin),
            b;
        while (begin < end) {
            b = this.view[begin++];
            if (b < 0x10)
                out.push("0", b.toString(16));
            else out.push(b.toString(16));
        }
        return out.join('');
    };

    /**
     * Decodes a hex encoded string to a ByteBuffer.
     * @param {string} str String to decode
     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
     *  {@link ByteBuffer.DEFAULT_ENDIAN}.
     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to
     *  {@link ByteBuffer.DEFAULT_NOASSERT}.
     * @returns {!ByteBuffer} ByteBuffer
     * @expose
     */
    ByteBuffer.fromHex = function(str, littleEndian, noAssert) {
        if (!noAssert) {
            if (typeof str !== 'string')
                throw TypeError("Illegal str: Not a string");
            if (str.length % 2 !== 0)
                throw TypeError("Illegal str: Length not a multiple of 2");
        }
        var k = str.length,
            bb = new ByteBuffer((k / 2) | 0, littleEndian),
            b;
        for (var i=0, j=0; i<k; i+=2) {
            b = parseInt(str.substring(i, i+2), 16);
            if (!noAssert)
                if (!isFinite(b) || b < 0 || b > 255)
                    throw TypeError("Illegal str: Contains non-hex characters");
            bb.view[j++] = b;
        }
        bb.limit = j;
        return bb;
    };

    // utfx-embeddable

    /**
     * utfx-embeddable (c) 2014 Daniel Wirtz <dcode@dcode.io>
     * Released under the Apache License, Version 2.0
     * see: https://github.com/dcodeIO/utfx for details
     */
    var utfx = function() {
        "use strict";

        /**
         * utfx namespace.
         * @inner
         * @type {!Object.<string,*>}
         */
        var utfx = {};

        /**
         * Maximum valid code point.
         * @type {number}
         * @const
         */
        utfx.MAX_CODEPOINT = 0x10FFFF;

        /**
         * Encodes UTF8 code points to UTF8 bytes.
         * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point
         *  respectively `null` if there are no more code points left or a single numeric code point.
         * @param {!function(number)} dst Bytes destination as a function successively called with the next byte
         */
        utfx.encodeUTF8 = function(src, dst) {
            var cp = null;
            if (typeof src === 'number')
                cp = src,
                src = function() { return null; };
            while (cp !== null || (cp = src()) !== null) {
                if (cp < 0x80)
                    dst(cp&0x7F);
                else if (cp < 0x800)
                    dst(((cp>>6)&0x1F)|0xC0),
                    dst((cp&0x3F)|0x80);
                else if (cp < 0x10000)
                    dst(((cp>>12)&0x0F)|0xE0),
                    dst(((cp>>6)&0x3F)|0x80),
                    dst((cp&0x3F)|0x80);
                else
                    dst(((cp>>18)&0x07)|0xF0),
                    dst(((cp>>12)&0x3F)|0x80),
                    dst(((cp>>6)&0x3F)|0x80),
                    dst((cp&0x3F)|0x80);
                cp = null;
            }
        };

        /**
         * Decodes UTF8 bytes to UTF8 code points.
         * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if there
         *  are no more bytes left.
         * @param {!function(number)} dst Code points destination as a function successively called with each decoded code point.
         * @throws {RangeError} If a starting byte is invalid in UTF8
         * @throws {Error} If the last sequence is truncated. Has an array property `bytes` holding the
         *  remaining bytes.
         */
        utfx.decodeUTF8 = function(src, dst) {
            var a, b, c, d, fail = function(b) {
                b = b.slice(0, b.indexOf(null));
                var err = Error(b.toString());
                err.name = "TruncatedError";
                err['bytes'] = b;
                throw err;
            };
            while ((a = src()) !== null) {
                if ((a&0x80) === 0)
                    dst(a);
                else if ((a&0xE0) === 0xC0)
                    ((b = src()) === null) && fail([a, b]),
                    dst(((a&0x1F)<<6) | (b&0x3F));
                else if ((a&0xF0) === 0xE0)
                    ((b=src()) === null || (c=src()) === null) && fail([a, b, c]),
                    dst(((a&0x0F)<<12) | ((b&0x3F)<<6) | (c&0x3F));
                else if ((a&0xF8) === 0xF0)
                    ((b=src()) === null || (c=src()) === null || (d=src()) === null) && fail([a, b, c ,d]),
                    dst(((a&0x07)<<18) | ((b&0x3F)<<12) | ((c&0x3F)<<6) | (d&0x3F));
                else throw RangeError("Illegal starting byte: "+a);
            }
        };

        /**
         * Converts UTF16 characters to UTF8 code points.
         * @param {!function():number|null} src Characters source as a function returning the next char code respectively
         *  `null` if there are no more characters left.
         * @param {!function(number)} dst Code points destination as a function successively called with each converted code
         *  point.
         */
        utfx.UTF16toUTF8 = function(src, dst) {
            var c1, c2 = null;
            while (true) {
                if ((c1 = c2 !== null ? c2 : src()) === null)
                    break;
                if (c1 >= 0xD800 && c1 <= 0xDFFF) {
                    if ((c2 = src()) !== null) {
                        if (c2 >= 0xDC00 && c2 <= 0xDFFF) {
                            dst((c1-0xD800)*0x400+c2-0xDC00+0x10000);
                            c2 = null; continue;
                        }
                    }
                }
                dst(c1);
            }
            if (c2 !== null) dst(c2);
        };

        /**
         * Converts UTF8 code points to UTF16 characters.
         * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point
         *  respectively `null` if there are no more code points left or a single numeric code point.
         * @param {!function(number)} dst Characters destination as a function successively called with each converted char code.
         * @throws {RangeError} If a code point is out of range
         */
        utfx.UTF8toUTF16 = function(src, dst) {
            var cp = null;
            if (typeof src === 'number')
                cp = src, src = function() { return null; };
            while (cp !== null || (cp = src()) !== null) {
                if (cp <= 0xFFFF)
                    dst(cp);
                else
                    cp -= 0x10000,
                    dst((cp>>10)+0xD800),
                    dst((cp%0x400)+0xDC00);
                cp = null;
            }
        };

        /**
         * Converts and encodes UTF16 characters to UTF8 bytes.
         * @param {!function():number|null} src Characters source as a function returning the next char code respectively `null`
         *  if there are no more characters left.
         * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.
         */
        utfx.encodeUTF16toUTF8 = function(src, dst) {
            utfx.UTF16toUTF8(src, function(cp) {
                utfx.encodeUTF8(cp, dst);
            });
        };

        /**
         * Decodes and converts UTF8 bytes to UTF16 characters.
         * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if there
         *  are no more bytes left.
         * @param {!function(number)} dst Characters destination as a function successively called with each converted char code.
         * @throws {RangeError} If a starting byte is invalid in UTF8
         * @throws {Error} If the last sequence is truncated. Has an array property `bytes` holding the remaining bytes.
         */
        utfx.decodeUTF8toUTF16 = function(src, dst) {
            utfx.decodeUTF8(src, function(cp) {
                utfx.UTF8toUTF16(cp, dst);
            });
        };

        /**
         * Calculates the byte length of an UTF8 code point.
         * @param {number} cp UTF8 code point
         * @returns {number} Byte length
         */
        utfx.calculateCodePoint = function(cp) {
            return (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;
        };

        /**
         * Calculates the number of UTF8 bytes required to store UTF8 code points.
         * @param {(!function():number|null)} src Code points source as a function returning the next code point respectively
         *  `null` if there are no more code points left.
         * @returns {number} The number of UTF8 bytes required
         */
        utfx.calculateUTF8 = function(src) {
            var cp, l=0;
            while ((cp = src()) !== null)
                l += (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;
            return l;
        };

        /**
         * Calculates the number of UTF8 code points respectively UTF8 bytes required to store UTF16 char codes.
         * @param {(!function():number|null)} src Characters source as a function returning the next char code respectively
         *  `null` if there are no more characters left.
         * @returns {!Array.<number>} The number of UTF8 code points at index 0 and the number of UTF8 bytes required at index 1.
         */
        utfx.calculateUTF16asUTF8 = function(src) {
            var n=0, l=0;
            utfx.UTF16toUTF8(src, function(cp) {
                ++n; l += (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;
            });
            return [n,l];
        };

        return utfx;
    }();

    // encodings/utf8

    /**
     * Encodes this ByteBuffer's contents between {@link ByteBuffer#offset} and {@link ByteBuffer#limit} to an UTF8 encoded
     *  string.
     * @returns {string} Hex encoded string
     * @throws {RangeError} If `offset > limit`
     * @expose
     */
    ByteBufferPrototype.toUTF8 = function(begin, end) {
        if (typeof begin === 'undefined') begin = this.offset;
        if (typeof end === 'undefined') end = this.limit;
        if (!this.noAssert) {
            if (typeof begin !== 'number' || begin % 1 !== 0)
                throw TypeError("Illegal begin: Not an integer");
            begin >>>= 0;
            if (typeof end !== 'number' || end % 1 !== 0)
                throw TypeError("Illegal end: Not an integer");
            end >>>= 0;
            if (begin < 0 || begin > end || end > this.buffer.byteLength)
                throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.byteLength);
        }
        var sd; try {
            utfx.decodeUTF8toUTF16(function() {
                return begin < end ? this.view[begin++] : null;
            }.bind(this), sd = stringDestination());
        } catch (e) {
            if (begin !== end)
                throw RangeError("Illegal range: Truncated data, "+begin+" != "+end);
        }
        return sd();
    };

    /**
     * Decodes an UTF8 encoded string to a ByteBuffer.
     * @param {string} str String to decode
     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
     *  {@link ByteBuffer.DEFAULT_ENDIAN}.
     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to
     *  {@link ByteBuffer.DEFAULT_NOASSERT}.
     * @returns {!ByteBuffer} ByteBuffer
     * @expose
     */
    ByteBuffer.fromUTF8 = function(str, littleEndian, noAssert) {
        if (!noAssert)
            if (typeof str !== 'string')
                throw TypeError("Illegal str: Not a string");
        var bb = new ByteBuffer(utfx.calculateUTF16asUTF8(stringSource(str), true)[1], littleEndian, noAssert),
            i = 0;
        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {
            bb.view[i++] = b;
        });
        bb.limit = i;
        return bb;
    };

    return ByteBuffer;
});

},{"long":712}],84:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

var objectCreate = Object.create || objectCreatePolyfill
var objectKeys = Object.keys || objectKeysPolyfill
var bind = Function.prototype.bind || functionBindPolyfill

function EventEmitter() {
  if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {
    this._events = objectCreate(null);
    this._eventsCount = 0;
  }

  this._maxListeners = this._maxListeners || undefined;
}
module.exports = EventEmitter;

// Backwards-compat with node 0.10.x
EventEmitter.EventEmitter = EventEmitter;

EventEmitter.prototype._events = undefined;
EventEmitter.prototype._maxListeners = undefined;

// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
var defaultMaxListeners = 10;

var hasDefineProperty;
try {
  var o = {};
  if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });
  hasDefineProperty = o.x === 0;
} catch (err) { hasDefineProperty = false }
if (hasDefineProperty) {
  Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
    enumerable: true,
    get: function() {
      return defaultMaxListeners;
    },
    set: function(arg) {
      // check whether the input is a positive number (whose value is zero or
      // greater and not a NaN).
      if (typeof arg !== 'number' || arg < 0 || arg !== arg)
        throw new TypeError('"defaultMaxListeners" must be a positive number');
      defaultMaxListeners = arg;
    }
  });
} else {
  EventEmitter.defaultMaxListeners = defaultMaxListeners;
}

// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
  if (typeof n !== 'number' || n < 0 || isNaN(n))
    throw new TypeError('"n" argument must be a positive number');
  this._maxListeners = n;
  return this;
};

function $getMaxListeners(that) {
  if (that._maxListeners === undefined)
    return EventEmitter.defaultMaxListeners;
  return that._maxListeners;
}

EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
  return $getMaxListeners(this);
};

// These standalone emit* functions are used to optimize calling of event
// handlers for fast cases because emit() itself often has a variable number of
// arguments and can be deoptimized because of that. These functions always have
// the same number of arguments and thus do not get deoptimized, so the code
// inside them can execute faster.
function emitNone(handler, isFn, self) {
  if (isFn)
    handler.call(self);
  else {
    var len = handler.length;
    var listeners = arrayClone(handler, len);
    for (var i = 0; i < len; ++i)
      listeners[i].call(self);
  }
}
function emitOne(handler, isFn, self, arg1) {
  if (isFn)
    handler.call(self, arg1);
  else {
    var len = handler.length;
    var listeners = arrayClone(handler, len);
    for (var i = 0; i < len; ++i)
      listeners[i].call(self, arg1);
  }
}
function emitTwo(handler, isFn, self, arg1, arg2) {
  if (isFn)
    handler.call(self, arg1, arg2);
  else {
    var len = handler.length;
    var listeners = arrayClone(handler, len);
    for (var i = 0; i < len; ++i)
      listeners[i].call(self, arg1, arg2);
  }
}
function emitThree(handler, isFn, self, arg1, arg2, arg3) {
  if (isFn)
    handler.call(self, arg1, arg2, arg3);
  else {
    var len = handler.length;
    var listeners = arrayClone(handler, len);
    for (var i = 0; i < len; ++i)
      listeners[i].call(self, arg1, arg2, arg3);
  }
}

function emitMany(handler, isFn, self, args) {
  if (isFn)
    handler.apply(self, args);
  else {
    var len = handler.length;
    var listeners = arrayClone(handler, len);
    for (var i = 0; i < len; ++i)
      listeners[i].apply(self, args);
  }
}

EventEmitter.prototype.emit = function emit(type) {
  var er, handler, len, args, i, events;
  var doError = (type === 'error');

  events = this._events;
  if (events)
    doError = (doError && events.error == null);
  else if (!doError)
    return false;

  // If there is no 'error' event listener then throw.
  if (doError) {
    if (arguments.length > 1)
      er = arguments[1];
    if (er instanceof Error) {
      throw er; // Unhandled 'error' event
    } else {
      // At least give some kind of context to the user
      var err = new Error('Unhandled "error" event. (' + er + ')');
      err.context = er;
      throw err;
    }
    return false;
  }

  handler = events[type];

  if (!handler)
    return false;

  var isFn = typeof handler === 'function';
  len = arguments.length;
  switch (len) {
      // fast cases
    case 1:
      emitNone(handler, isFn, this);
      break;
    case 2:
      emitOne(handler, isFn, this, arguments[1]);
      break;
    case 3:
      emitTwo(handler, isFn, this, arguments[1], arguments[2]);
      break;
    case 4:
      emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
      break;
      // slower
    default:
      args = new Array(len - 1);
      for (i = 1; i < len; i++)
        args[i - 1] = arguments[i];
      emitMany(handler, isFn, this, args);
  }

  return true;
};

function _addListener(target, type, listener, prepend) {
  var m;
  var events;
  var existing;

  if (typeof listener !== 'function')
    throw new TypeError('"listener" argument must be a function');

  events = target._events;
  if (!events) {
    events = target._events = objectCreate(null);
    target._eventsCount = 0;
  } else {
    // To avoid recursion in the case that type === "newListener"! Before
    // adding it to the listeners, first emit "newListener".
    if (events.newListener) {
      target.emit('newListener', type,
          listener.listener ? listener.listener : listener);

      // Re-assign `events` because a newListener handler could have caused the
      // this._events to be assigned to a new object
      events = target._events;
    }
    existing = events[type];
  }

  if (!existing) {
    // Optimize the case of one listener. Don't need the extra array object.
    existing = events[type] = listener;
    ++target._eventsCount;
  } else {
    if (typeof existing === 'function') {
      // Adding the second element, need to change to array.
      existing = events[type] =
          prepend ? [listener, existing] : [existing, listener];
    } else {
      // If we've already got an array, just append.
      if (prepend) {
        existing.unshift(listener);
      } else {
        existing.push(listener);
      }
    }

    // Check for listener leak
    if (!existing.warned) {
      m = $getMaxListeners(target);
      if (m && m > 0 && existing.length > m) {
        existing.warned = true;
        var w = new Error('Possible EventEmitter memory leak detected. ' +
            existing.length + ' "' + String(type) + '" listeners ' +
            'added. Use emitter.setMaxListeners() to ' +
            'increase limit.');
        w.name = 'MaxListenersExceededWarning';
        w.emitter = target;
        w.type = type;
        w.count = existing.length;
        if (typeof console === 'object' && console.warn) {
          console.warn('%s: %s', w.name, w.message);
        }
      }
    }
  }

  return target;
}

EventEmitter.prototype.addListener = function addListener(type, listener) {
  return _addListener(this, type, listener, false);
};

EventEmitter.prototype.on = EventEmitter.prototype.addListener;

EventEmitter.prototype.prependListener =
    function prependListener(type, listener) {
      return _addListener(this, type, listener, true);
    };

function onceWrapper() {
  if (!this.fired) {
    this.target.removeListener(this.type, this.wrapFn);
    this.fired = true;
    switch (arguments.length) {
      case 0:
        return this.listener.call(this.target);
      case 1:
        return this.listener.call(this.target, arguments[0]);
      case 2:
        return this.listener.call(this.target, arguments[0], arguments[1]);
      case 3:
        return this.listener.call(this.target, arguments[0], arguments[1],
            arguments[2]);
      default:
        var args = new Array(arguments.length);
        for (var i = 0; i < args.length; ++i)
          args[i] = arguments[i];
        this.listener.apply(this.target, args);
    }
  }
}

function _onceWrap(target, type, listener) {
  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
  var wrapped = bind.call(onceWrapper, state);
  wrapped.listener = listener;
  state.wrapFn = wrapped;
  return wrapped;
}

EventEmitter.prototype.once = function once(type, listener) {
  if (typeof listener !== 'function')
    throw new TypeError('"listener" argument must be a function');
  this.on(type, _onceWrap(this, type, listener));
  return this;
};

EventEmitter.prototype.prependOnceListener =
    function prependOnceListener(type, listener) {
      if (typeof listener !== 'function')
        throw new TypeError('"listener" argument must be a function');
      this.prependListener(type, _onceWrap(this, type, listener));
      return this;
    };

// Emits a 'removeListener' event if and only if the listener was removed.
EventEmitter.prototype.removeListener =
    function removeListener(type, listener) {
      var list, events, position, i, originalListener;

      if (typeof listener !== 'function')
        throw new TypeError('"listener" argument must be a function');

      events = this._events;
      if (!events)
        return this;

      list = events[type];
      if (!list)
        return this;

      if (list === listener || list.listener === listener) {
        if (--this._eventsCount === 0)
          this._events = objectCreate(null);
        else {
          delete events[type];
          if (events.removeListener)
            this.emit('removeListener', type, list.listener || listener);
        }
      } else if (typeof list !== 'function') {
        position = -1;

        for (i = list.length - 1; i >= 0; i--) {
          if (list[i] === listener || list[i].listener === listener) {
            originalListener = list[i].listener;
            position = i;
            break;
          }
        }

        if (position < 0)
          return this;

        if (position === 0)
          list.shift();
        else
          spliceOne(list, position);

        if (list.length === 1)
          events[type] = list[0];

        if (events.removeListener)
          this.emit('removeListener', type, originalListener || listener);
      }

      return this;
    };

EventEmitter.prototype.removeAllListeners =
    function removeAllListeners(type) {
      var listeners, events, i;

      events = this._events;
      if (!events)
        return this;

      // not listening for removeListener, no need to emit
      if (!events.removeListener) {
        if (arguments.length === 0) {
          this._events = objectCreate(null);
          this._eventsCount = 0;
        } else if (events[type]) {
          if (--this._eventsCount === 0)
            this._events = objectCreate(null);
          else
            delete events[type];
        }
        return this;
      }

      // emit removeListener for all listeners on all events
      if (arguments.length === 0) {
        var keys = objectKeys(events);
        var key;
        for (i = 0; i < keys.length; ++i) {
          key = keys[i];
          if (key === 'removeListener') continue;
          this.removeAllListeners(key);
        }
        this.removeAllListeners('removeListener');
        this._events = objectCreate(null);
        this._eventsCount = 0;
        return this;
      }

      listeners = events[type];

      if (typeof listeners === 'function') {
        this.removeListener(type, listeners);
      } else if (listeners) {
        // LIFO order
        for (i = listeners.length - 1; i >= 0; i--) {
          this.removeListener(type, listeners[i]);
        }
      }

      return this;
    };

function _listeners(target, type, unwrap) {
  var events = target._events;

  if (!events)
    return [];

  var evlistener = events[type];
  if (!evlistener)
    return [];

  if (typeof evlistener === 'function')
    return unwrap ? [evlistener.listener || evlistener] : [evlistener];

  return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
}

EventEmitter.prototype.listeners = function listeners(type) {
  return _listeners(this, type, true);
};

EventEmitter.prototype.rawListeners = function rawListeners(type) {
  return _listeners(this, type, false);
};

EventEmitter.listenerCount = function(emitter, type) {
  if (typeof emitter.listenerCount === 'function') {
    return emitter.listenerCount(type);
  } else {
    return listenerCount.call(emitter, type);
  }
};

EventEmitter.prototype.listenerCount = listenerCount;
function listenerCount(type) {
  var events = this._events;

  if (events) {
    var evlistener = events[type];

    if (typeof evlistener === 'function') {
      return 1;
    } else if (evlistener) {
      return evlistener.length;
    }
  }

  return 0;
}

EventEmitter.prototype.eventNames = function eventNames() {
  return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
};

// About 1.5x faster than the two-arg version of Array#splice().
function spliceOne(list, index) {
  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
    list[i] = list[k];
  list.pop();
}

function arrayClone(arr, n) {
  var copy = new Array(n);
  for (var i = 0; i < n; ++i)
    copy[i] = arr[i];
  return copy;
}

function unwrapListeners(arr) {
  var ret = new Array(arr.length);
  for (var i = 0; i < ret.length; ++i) {
    ret[i] = arr[i].listener || arr[i];
  }
  return ret;
}

function objectCreatePolyfill(proto) {
  var F = function() {};
  F.prototype = proto;
  return new F;
}
function objectKeysPolyfill(obj) {
  var keys = [];
  for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) {
    keys.push(k);
  }
  return k;
}
function functionBindPolyfill(context) {
  var fn = this;
  return function () {
    return fn.apply(context, arguments);
  };
}

},{}],85:[function(require,module,exports){
var http = require('http')
var url = require('url')

var https = module.exports

for (var key in http) {
  if (http.hasOwnProperty(key)) https[key] = http[key]
}

https.request = function (params, cb) {
  params = validateParams(params)
  return http.request.call(this, params, cb)
}

https.get = function (params, cb) {
  params = validateParams(params)
  return http.get.call(this, params, cb)
}

function validateParams (params) {
  if (typeof params === 'string') {
    params = url.parse(params)
  }
  if (!params.protocol) {
    params.protocol = 'https:'
  }
  if (params.protocol !== 'https:') {
    throw new Error('Protocol "' + params.protocol + '" not supported. Expected "https:"')
  }
  return params
}

},{"http":732,"url":753}],86:[function(require,module,exports){
/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
exports.read = function (buffer, offset, isLE, mLen, nBytes) {
  var e, m
  var eLen = (nBytes * 8) - mLen - 1
  var eMax = (1 << eLen) - 1
  var eBias = eMax >> 1
  var nBits = -7
  var i = isLE ? (nBytes - 1) : 0
  var d = isLE ? -1 : 1
  var s = buffer[offset + i]

  i += d

  e = s & ((1 << (-nBits)) - 1)
  s >>= (-nBits)
  nBits += eLen
  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}

  m = e & ((1 << (-nBits)) - 1)
  e >>= (-nBits)
  nBits += mLen
  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}

  if (e === 0) {
    e = 1 - eBias
  } else if (e === eMax) {
    return m ? NaN : ((s ? -1 : 1) * Infinity)
  } else {
    m = m + Math.pow(2, mLen)
    e = e - eBias
  }
  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
}

exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
  var e, m, c
  var eLen = (nBytes * 8) - mLen - 1
  var eMax = (1 << eLen) - 1
  var eBias = eMax >> 1
  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
  var i = isLE ? 0 : (nBytes - 1)
  var d = isLE ? 1 : -1
  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0

  value = Math.abs(value)

  if (isNaN(value) || value === Infinity) {
    m = isNaN(value) ? 1 : 0
    e = eMax
  } else {
    e = Math.floor(Math.log(value) / Math.LN2)
    if (value * (c = Math.pow(2, -e)) < 1) {
      e--
      c *= 2
    }
    if (e + eBias >= 1) {
      value += rt / c
    } else {
      value += rt * Math.pow(2, 1 - eBias)
    }
    if (value * c >= 2) {
      e++
      c /= 2
    }

    if (e + eBias >= eMax) {
      m = 0
      e = eMax
    } else if (e + eBias >= 1) {
      m = ((value * c) - 1) * Math.pow(2, mLen)
      e = e + eBias
    } else {
      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
      e = 0
    }
  }

  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}

  e = (e << mLen) | m
  eLen += mLen
  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}

  buffer[offset + i - d] |= s * 128
}

},{}],87:[function(require,module,exports){
/**
 * MIT License
 * 
 * Copyright (c) 2014-present, Lee Byron and other contributors.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
  typeof define === 'function' && define.amd ? define(['exports'], factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Immutable = {}));
}(this, (function (exports) { 'use strict';

  var DELETE = 'delete';

  // Constants describing the size of trie nodes.
  var SHIFT = 5; // Resulted in best performance after ______?
  var SIZE = 1 << SHIFT;
  var MASK = SIZE - 1;

  // A consistent shared value representing "not set" which equals nothing other
  // than itself, and nothing that could be provided externally.
  var NOT_SET = {};

  // Boolean references, Rough equivalent of `bool &`.
  function MakeRef() {
    return { value: false };
  }

  function SetRef(ref) {
    if (ref) {
      ref.value = true;
    }
  }

  // A function which returns a value representing an "owner" for transient writes
  // to tries. The return value will only ever equal itself, and will not equal
  // the return of any subsequent call of this function.
  function OwnerID() {}

  function ensureSize(iter) {
    if (iter.size === undefined) {
      iter.size = iter.__iterate(returnTrue);
    }
    return iter.size;
  }

  function wrapIndex(iter, index) {
    // This implements "is array index" which the ECMAString spec defines as:
    //
    //     A String property name P is an array index if and only if
    //     ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal
    //     to 2^32−1.
    //
    // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects
    if (typeof index !== 'number') {
      var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32
      if ('' + uint32Index !== index || uint32Index === 4294967295) {
        return NaN;
      }
      index = uint32Index;
    }
    return index < 0 ? ensureSize(iter) + index : index;
  }

  function returnTrue() {
    return true;
  }

  function wholeSlice(begin, end, size) {
    return (
      ((begin === 0 && !isNeg(begin)) ||
        (size !== undefined && begin <= -size)) &&
      (end === undefined || (size !== undefined && end >= size))
    );
  }

  function resolveBegin(begin, size) {
    return resolveIndex(begin, size, 0);
  }

  function resolveEnd(end, size) {
    return resolveIndex(end, size, size);
  }

  function resolveIndex(index, size, defaultIndex) {
    // Sanitize indices using this shorthand for ToInt32(argument)
    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
    return index === undefined
      ? defaultIndex
      : isNeg(index)
      ? size === Infinity
        ? size
        : Math.max(0, size + index) | 0
      : size === undefined || size === index
      ? index
      : Math.min(size, index) | 0;
  }

  function isNeg(value) {
    // Account for -0 which is negative, but not less than 0.
    return value < 0 || (value === 0 && 1 / value === -Infinity);
  }

  var IS_COLLECTION_SYMBOL = '@@__IMMUTABLE_ITERABLE__@@';

  function isCollection(maybeCollection) {
    return Boolean(maybeCollection && maybeCollection[IS_COLLECTION_SYMBOL]);
  }

  var IS_KEYED_SYMBOL = '@@__IMMUTABLE_KEYED__@@';

  function isKeyed(maybeKeyed) {
    return Boolean(maybeKeyed && maybeKeyed[IS_KEYED_SYMBOL]);
  }

  var IS_INDEXED_SYMBOL = '@@__IMMUTABLE_INDEXED__@@';

  function isIndexed(maybeIndexed) {
    return Boolean(maybeIndexed && maybeIndexed[IS_INDEXED_SYMBOL]);
  }

  function isAssociative(maybeAssociative) {
    return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);
  }

  var Collection = function Collection(value) {
    return isCollection(value) ? value : Seq(value);
  };

  var KeyedCollection = /*@__PURE__*/(function (Collection) {
    function KeyedCollection(value) {
      return isKeyed(value) ? value : KeyedSeq(value);
    }

    if ( Collection ) KeyedCollection.__proto__ = Collection;
    KeyedCollection.prototype = Object.create( Collection && Collection.prototype );
    KeyedCollection.prototype.constructor = KeyedCollection;

    return KeyedCollection;
  }(Collection));

  var IndexedCollection = /*@__PURE__*/(function (Collection) {
    function IndexedCollection(value) {
      return isIndexed(value) ? value : IndexedSeq(value);
    }

    if ( Collection ) IndexedCollection.__proto__ = Collection;
    IndexedCollection.prototype = Object.create( Collection && Collection.prototype );
    IndexedCollection.prototype.constructor = IndexedCollection;

    return IndexedCollection;
  }(Collection));

  var SetCollection = /*@__PURE__*/(function (Collection) {
    function SetCollection(value) {
      return isCollection(value) && !isAssociative(value) ? value : SetSeq(value);
    }

    if ( Collection ) SetCollection.__proto__ = Collection;
    SetCollection.prototype = Object.create( Collection && Collection.prototype );
    SetCollection.prototype.constructor = SetCollection;

    return SetCollection;
  }(Collection));

  Collection.Keyed = KeyedCollection;
  Collection.Indexed = IndexedCollection;
  Collection.Set = SetCollection;

  var IS_SEQ_SYMBOL = '@@__IMMUTABLE_SEQ__@@';

  function isSeq(maybeSeq) {
    return Boolean(maybeSeq && maybeSeq[IS_SEQ_SYMBOL]);
  }

  var IS_RECORD_SYMBOL = '@@__IMMUTABLE_RECORD__@@';

  function isRecord(maybeRecord) {
    return Boolean(maybeRecord && maybeRecord[IS_RECORD_SYMBOL]);
  }

  function isImmutable(maybeImmutable) {
    return isCollection(maybeImmutable) || isRecord(maybeImmutable);
  }

  var IS_ORDERED_SYMBOL = '@@__IMMUTABLE_ORDERED__@@';

  function isOrdered(maybeOrdered) {
    return Boolean(maybeOrdered && maybeOrdered[IS_ORDERED_SYMBOL]);
  }

  var ITERATE_KEYS = 0;
  var ITERATE_VALUES = 1;
  var ITERATE_ENTRIES = 2;

  var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
  var FAUX_ITERATOR_SYMBOL = '@@iterator';

  var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;

  var Iterator = function Iterator(next) {
    this.next = next;
  };

  Iterator.prototype.toString = function toString () {
    return '[Iterator]';
  };

  Iterator.KEYS = ITERATE_KEYS;
  Iterator.VALUES = ITERATE_VALUES;
  Iterator.ENTRIES = ITERATE_ENTRIES;

  Iterator.prototype.inspect = Iterator.prototype.toSource = function () {
    return this.toString();
  };
  Iterator.prototype[ITERATOR_SYMBOL] = function () {
    return this;
  };

  function iteratorValue(type, k, v, iteratorResult) {
    var value = type === 0 ? k : type === 1 ? v : [k, v];
    iteratorResult
      ? (iteratorResult.value = value)
      : (iteratorResult = {
          value: value,
          done: false,
        });
    return iteratorResult;
  }

  function iteratorDone() {
    return { value: undefined, done: true };
  }

  function hasIterator(maybeIterable) {
    if (Array.isArray(maybeIterable)) {
      // IE11 trick as it does not support `Symbol.iterator`
      return true;
    }

    return !!getIteratorFn(maybeIterable);
  }

  function isIterator(maybeIterator) {
    return maybeIterator && typeof maybeIterator.next === 'function';
  }

  function getIterator(iterable) {
    var iteratorFn = getIteratorFn(iterable);
    return iteratorFn && iteratorFn.call(iterable);
  }

  function getIteratorFn(iterable) {
    var iteratorFn =
      iterable &&
      ((REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||
        iterable[FAUX_ITERATOR_SYMBOL]);
    if (typeof iteratorFn === 'function') {
      return iteratorFn;
    }
  }

  function isEntriesIterable(maybeIterable) {
    var iteratorFn = getIteratorFn(maybeIterable);
    return iteratorFn && iteratorFn === maybeIterable.entries;
  }

  function isKeysIterable(maybeIterable) {
    var iteratorFn = getIteratorFn(maybeIterable);
    return iteratorFn && iteratorFn === maybeIterable.keys;
  }

  var hasOwnProperty = Object.prototype.hasOwnProperty;

  function isArrayLike(value) {
    if (Array.isArray(value) || typeof value === 'string') {
      return true;
    }

    return (
      value &&
      typeof value === 'object' &&
      Number.isInteger(value.length) &&
      value.length >= 0 &&
      (value.length === 0
        ? // Only {length: 0} is considered Array-like.
          Object.keys(value).length === 1
        : // An object is only Array-like if it has a property where the last value
          // in the array-like may be found (which could be undefined).
          value.hasOwnProperty(value.length - 1))
    );
  }

  var Seq = /*@__PURE__*/(function (Collection) {
    function Seq(value) {
      return value === undefined || value === null
        ? emptySequence()
        : isImmutable(value)
        ? value.toSeq()
        : seqFromValue(value);
    }

    if ( Collection ) Seq.__proto__ = Collection;
    Seq.prototype = Object.create( Collection && Collection.prototype );
    Seq.prototype.constructor = Seq;

    Seq.prototype.toSeq = function toSeq () {
      return this;
    };

    Seq.prototype.toString = function toString () {
      return this.__toString('Seq {', '}');
    };

    Seq.prototype.cacheResult = function cacheResult () {
      if (!this._cache && this.__iterateUncached) {
        this._cache = this.entrySeq().toArray();
        this.size = this._cache.length;
      }
      return this;
    };

    // abstract __iterateUncached(fn, reverse)

    Seq.prototype.__iterate = function __iterate (fn, reverse) {
      var cache = this._cache;
      if (cache) {
        var size = cache.length;
        var i = 0;
        while (i !== size) {
          var entry = cache[reverse ? size - ++i : i++];
          if (fn(entry[1], entry[0], this) === false) {
            break;
          }
        }
        return i;
      }
      return this.__iterateUncached(fn, reverse);
    };

    // abstract __iteratorUncached(type, reverse)

    Seq.prototype.__iterator = function __iterator (type, reverse) {
      var cache = this._cache;
      if (cache) {
        var size = cache.length;
        var i = 0;
        return new Iterator(function () {
          if (i === size) {
            return iteratorDone();
          }
          var entry = cache[reverse ? size - ++i : i++];
          return iteratorValue(type, entry[0], entry[1]);
        });
      }
      return this.__iteratorUncached(type, reverse);
    };

    return Seq;
  }(Collection));

  var KeyedSeq = /*@__PURE__*/(function (Seq) {
    function KeyedSeq(value) {
      return value === undefined || value === null
        ? emptySequence().toKeyedSeq()
        : isCollection(value)
        ? isKeyed(value)
          ? value.toSeq()
          : value.fromEntrySeq()
        : isRecord(value)
        ? value.toSeq()
        : keyedSeqFromValue(value);
    }

    if ( Seq ) KeyedSeq.__proto__ = Seq;
    KeyedSeq.prototype = Object.create( Seq && Seq.prototype );
    KeyedSeq.prototype.constructor = KeyedSeq;

    KeyedSeq.prototype.toKeyedSeq = function toKeyedSeq () {
      return this;
    };

    return KeyedSeq;
  }(Seq));

  var IndexedSeq = /*@__PURE__*/(function (Seq) {
    function IndexedSeq(value) {
      return value === undefined || value === null
        ? emptySequence()
        : isCollection(value)
        ? isKeyed(value)
          ? value.entrySeq()
          : value.toIndexedSeq()
        : isRecord(value)
        ? value.toSeq().entrySeq()
        : indexedSeqFromValue(value);
    }

    if ( Seq ) IndexedSeq.__proto__ = Seq;
    IndexedSeq.prototype = Object.create( Seq && Seq.prototype );
    IndexedSeq.prototype.constructor = IndexedSeq;

    IndexedSeq.of = function of (/*...values*/) {
      return IndexedSeq(arguments);
    };

    IndexedSeq.prototype.toIndexedSeq = function toIndexedSeq () {
      return this;
    };

    IndexedSeq.prototype.toString = function toString () {
      return this.__toString('Seq [', ']');
    };

    return IndexedSeq;
  }(Seq));

  var SetSeq = /*@__PURE__*/(function (Seq) {
    function SetSeq(value) {
      return (
        isCollection(value) && !isAssociative(value) ? value : IndexedSeq(value)
      ).toSetSeq();
    }

    if ( Seq ) SetSeq.__proto__ = Seq;
    SetSeq.prototype = Object.create( Seq && Seq.prototype );
    SetSeq.prototype.constructor = SetSeq;

    SetSeq.of = function of (/*...values*/) {
      return SetSeq(arguments);
    };

    SetSeq.prototype.toSetSeq = function toSetSeq () {
      return this;
    };

    return SetSeq;
  }(Seq));

  Seq.isSeq = isSeq;
  Seq.Keyed = KeyedSeq;
  Seq.Set = SetSeq;
  Seq.Indexed = IndexedSeq;

  Seq.prototype[IS_SEQ_SYMBOL] = true;

  // #pragma Root Sequences

  var ArraySeq = /*@__PURE__*/(function (IndexedSeq) {
    function ArraySeq(array) {
      this._array = array;
      this.size = array.length;
    }

    if ( IndexedSeq ) ArraySeq.__proto__ = IndexedSeq;
    ArraySeq.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );
    ArraySeq.prototype.constructor = ArraySeq;

    ArraySeq.prototype.get = function get (index, notSetValue) {
      return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue;
    };

    ArraySeq.prototype.__iterate = function __iterate (fn, reverse) {
      var array = this._array;
      var size = array.length;
      var i = 0;
      while (i !== size) {
        var ii = reverse ? size - ++i : i++;
        if (fn(array[ii], ii, this) === false) {
          break;
        }
      }
      return i;
    };

    ArraySeq.prototype.__iterator = function __iterator (type, reverse) {
      var array = this._array;
      var size = array.length;
      var i = 0;
      return new Iterator(function () {
        if (i === size) {
          return iteratorDone();
        }
        var ii = reverse ? size - ++i : i++;
        return iteratorValue(type, ii, array[ii]);
      });
    };

    return ArraySeq;
  }(IndexedSeq));

  var ObjectSeq = /*@__PURE__*/(function (KeyedSeq) {
    function ObjectSeq(object) {
      var keys = Object.keys(object).concat(
        Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : []
      );
      this._object = object;
      this._keys = keys;
      this.size = keys.length;
    }

    if ( KeyedSeq ) ObjectSeq.__proto__ = KeyedSeq;
    ObjectSeq.prototype = Object.create( KeyedSeq && KeyedSeq.prototype );
    ObjectSeq.prototype.constructor = ObjectSeq;

    ObjectSeq.prototype.get = function get (key, notSetValue) {
      if (notSetValue !== undefined && !this.has(key)) {
        return notSetValue;
      }
      return this._object[key];
    };

    ObjectSeq.prototype.has = function has (key) {
      return hasOwnProperty.call(this._object, key);
    };

    ObjectSeq.prototype.__iterate = function __iterate (fn, reverse) {
      var object = this._object;
      var keys = this._keys;
      var size = keys.length;
      var i = 0;
      while (i !== size) {
        var key = keys[reverse ? size - ++i : i++];
        if (fn(object[key], key, this) === false) {
          break;
        }
      }
      return i;
    };

    ObjectSeq.prototype.__iterator = function __iterator (type, reverse) {
      var object = this._object;
      var keys = this._keys;
      var size = keys.length;
      var i = 0;
      return new Iterator(function () {
        if (i === size) {
          return iteratorDone();
        }
        var key = keys[reverse ? size - ++i : i++];
        return iteratorValue(type, key, object[key]);
      });
    };

    return ObjectSeq;
  }(KeyedSeq));
  ObjectSeq.prototype[IS_ORDERED_SYMBOL] = true;

  var CollectionSeq = /*@__PURE__*/(function (IndexedSeq) {
    function CollectionSeq(collection) {
      this._collection = collection;
      this.size = collection.length || collection.size;
    }

    if ( IndexedSeq ) CollectionSeq.__proto__ = IndexedSeq;
    CollectionSeq.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );
    CollectionSeq.prototype.constructor = CollectionSeq;

    CollectionSeq.prototype.__iterateUncached = function __iterateUncached (fn, reverse) {
      if (reverse) {
        return this.cacheResult().__iterate(fn, reverse);
      }
      var collection = this._collection;
      var iterator = getIterator(collection);
      var iterations = 0;
      if (isIterator(iterator)) {
        var step;
        while (!(step = iterator.next()).done) {
          if (fn(step.value, iterations++, this) === false) {
            break;
          }
        }
      }
      return iterations;
    };

    CollectionSeq.prototype.__iteratorUncached = function __iteratorUncached (type, reverse) {
      if (reverse) {
        return this.cacheResult().__iterator(type, reverse);
      }
      var collection = this._collection;
      var iterator = getIterator(collection);
      if (!isIterator(iterator)) {
        return new Iterator(iteratorDone);
      }
      var iterations = 0;
      return new Iterator(function () {
        var step = iterator.next();
        return step.done ? step : iteratorValue(type, iterations++, step.value);
      });
    };

    return CollectionSeq;
  }(IndexedSeq));

  // # pragma Helper functions

  var EMPTY_SEQ;

  function emptySequence() {
    return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));
  }

  function keyedSeqFromValue(value) {
    var seq = maybeIndexedSeqFromValue(value);
    if (seq) {
      return seq.fromEntrySeq();
    }
    if (typeof value === 'object') {
      return new ObjectSeq(value);
    }
    throw new TypeError(
      'Expected Array or collection object of [k, v] entries, or keyed object: ' +
        value
    );
  }

  function indexedSeqFromValue(value) {
    var seq = maybeIndexedSeqFromValue(value);
    if (seq) {
      return seq;
    }
    throw new TypeError(
      'Expected Array or collection object of values: ' + value
    );
  }

  function seqFromValue(value) {
    var seq = maybeIndexedSeqFromValue(value);
    if (seq) {
      return isEntriesIterable(value)
        ? seq.fromEntrySeq()
        : isKeysIterable(value)
        ? seq.toSetSeq()
        : seq;
    }
    if (typeof value === 'object') {
      return new ObjectSeq(value);
    }
    throw new TypeError(
      'Expected Array or collection object of values, or keyed object: ' + value
    );
  }

  function maybeIndexedSeqFromValue(value) {
    return isArrayLike(value)
      ? new ArraySeq(value)
      : hasIterator(value)
      ? new CollectionSeq(value)
      : undefined;
  }

  var IS_MAP_SYMBOL = '@@__IMMUTABLE_MAP__@@';

  function isMap(maybeMap) {
    return Boolean(maybeMap && maybeMap[IS_MAP_SYMBOL]);
  }

  function isOrderedMap(maybeOrderedMap) {
    return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);
  }

  function isValueObject(maybeValue) {
    return Boolean(
      maybeValue &&
        typeof maybeValue.equals === 'function' &&
        typeof maybeValue.hashCode === 'function'
    );
  }

  /**
   * An extension of the "same-value" algorithm as [described for use by ES6 Map
   * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)
   *
   * NaN is considered the same as NaN, however -0 and 0 are considered the same
   * value, which is different from the algorithm described by
   * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
   *
   * This is extended further to allow Objects to describe the values they
   * represent, by way of `valueOf` or `equals` (and `hashCode`).
   *
   * Note: because of this extension, the key equality of Immutable.Map and the
   * value equality of Immutable.Set will differ from ES6 Map and Set.
   *
   * ### Defining custom values
   *
   * The easiest way to describe the value an object represents is by implementing
   * `valueOf`. For example, `Date` represents a value by returning a unix
   * timestamp for `valueOf`:
   *
   *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...
   *     var date2 = new Date(1234567890000);
   *     date1.valueOf(); // 1234567890000
   *     assert( date1 !== date2 );
   *     assert( Immutable.is( date1, date2 ) );
   *
   * Note: overriding `valueOf` may have other implications if you use this object
   * where JavaScript expects a primitive, such as implicit string coercion.
   *
   * For more complex types, especially collections, implementing `valueOf` may
   * not be performant. An alternative is to implement `equals` and `hashCode`.
   *
   * `equals` takes another object, presumably of similar type, and returns true
   * if it is equal. Equality is symmetrical, so the same result should be
   * returned if this and the argument are flipped.
   *
   *     assert( a.equals(b) === b.equals(a) );
   *
   * `hashCode` returns a 32bit integer number representing the object which will
   * be used to determine how to store the value object in a Map or Set. You must
   * provide both or neither methods, one must not exist without the other.
   *
   * Also, an important relationship between these methods must be upheld: if two
   * values are equal, they *must* return the same hashCode. If the values are not
   * equal, they might have the same hashCode; this is called a hash collision,
   * and while undesirable for performance reasons, it is acceptable.
   *
   *     if (a.equals(b)) {
   *       assert( a.hashCode() === b.hashCode() );
   *     }
   *
   * All Immutable collections are Value Objects: they implement `equals()`
   * and `hashCode()`.
   */
  function is(valueA, valueB) {
    if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
      return true;
    }
    if (!valueA || !valueB) {
      return false;
    }
    if (
      typeof valueA.valueOf === 'function' &&
      typeof valueB.valueOf === 'function'
    ) {
      valueA = valueA.valueOf();
      valueB = valueB.valueOf();
      if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
        return true;
      }
      if (!valueA || !valueB) {
        return false;
      }
    }
    return !!(
      isValueObject(valueA) &&
      isValueObject(valueB) &&
      valueA.equals(valueB)
    );
  }

  var imul =
    typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2
      ? Math.imul
      : function imul(a, b) {
          a |= 0; // int
          b |= 0; // int
          var c = a & 0xffff;
          var d = b & 0xffff;
          // Shift by 0 fixes the sign on the high part.
          return (c * d + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0)) | 0; // int
        };

  // v8 has an optimization for storing 31-bit signed numbers.
  // Values which have either 00 or 11 as the high order bits qualify.
  // This function drops the highest order bit in a signed number, maintaining
  // the sign bit.
  function smi(i32) {
    return ((i32 >>> 1) & 0x40000000) | (i32 & 0xbfffffff);
  }

  var defaultValueOf = Object.prototype.valueOf;

  function hash(o) {
    if (o == null) {
      return hashNullish(o);
    }

    if (typeof o.hashCode === 'function') {
      // Drop any high bits from accidentally long hash codes.
      return smi(o.hashCode(o));
    }

    var v = valueOf(o);

    if (v == null) {
      return hashNullish(v);
    }

    switch (typeof v) {
      case 'boolean':
        // The hash values for built-in constants are a 1 value for each 5-byte
        // shift region expect for the first, which encodes the value. This
        // reduces the odds of a hash collision for these common values.
        return v ? 0x42108421 : 0x42108420;
      case 'number':
        return hashNumber(v);
      case 'string':
        return v.length > STRING_HASH_CACHE_MIN_STRLEN
          ? cachedHashString(v)
          : hashString(v);
      case 'object':
      case 'function':
        return hashJSObj(v);
      case 'symbol':
        return hashSymbol(v);
      default:
        if (typeof v.toString === 'function') {
          return hashString(v.toString());
        }
        throw new Error('Value type ' + typeof v + ' cannot be hashed.');
    }
  }

  function hashNullish(nullish) {
    return nullish === null ? 0x42108422 : /* undefined */ 0x42108423;
  }

  // Compress arbitrarily large numbers into smi hashes.
  function hashNumber(n) {
    if (n !== n || n === Infinity) {
      return 0;
    }
    var hash = n | 0;
    if (hash !== n) {
      hash ^= n * 0xffffffff;
    }
    while (n > 0xffffffff) {
      n /= 0xffffffff;
      hash ^= n;
    }
    return smi(hash);
  }

  function cachedHashString(string) {
    var hashed = stringHashCache[string];
    if (hashed === undefined) {
      hashed = hashString(string);
      if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {
        STRING_HASH_CACHE_SIZE = 0;
        stringHashCache = {};
      }
      STRING_HASH_CACHE_SIZE++;
      stringHashCache[string] = hashed;
    }
    return hashed;
  }

  // http://jsperf.com/hashing-strings
  function hashString(string) {
    // This is the hash from JVM
    // The hash code for a string is computed as
    // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],
    // where s[i] is the ith character of the string and n is the length of
    // the string. We "mod" the result to make it between 0 (inclusive) and 2^31
    // (exclusive) by dropping high bits.
    var hashed = 0;
    for (var ii = 0; ii < string.length; ii++) {
      hashed = (31 * hashed + string.charCodeAt(ii)) | 0;
    }
    return smi(hashed);
  }

  function hashSymbol(sym) {
    var hashed = symbolMap[sym];
    if (hashed !== undefined) {
      return hashed;
    }

    hashed = nextHash();

    symbolMap[sym] = hashed;

    return hashed;
  }

  function hashJSObj(obj) {
    var hashed;
    if (usingWeakMap) {
      hashed = weakMap.get(obj);
      if (hashed !== undefined) {
        return hashed;
      }
    }

    hashed = obj[UID_HASH_KEY];
    if (hashed !== undefined) {
      return hashed;
    }

    if (!canDefineProperty) {
      hashed = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];
      if (hashed !== undefined) {
        return hashed;
      }

      hashed = getIENodeHash(obj);
      if (hashed !== undefined) {
        return hashed;
      }
    }

    hashed = nextHash();

    if (usingWeakMap) {
      weakMap.set(obj, hashed);
    } else if (isExtensible !== undefined && isExtensible(obj) === false) {
      throw new Error('Non-extensible objects are not allowed as keys.');
    } else if (canDefineProperty) {
      Object.defineProperty(obj, UID_HASH_KEY, {
        enumerable: false,
        configurable: false,
        writable: false,
        value: hashed,
      });
    } else if (
      obj.propertyIsEnumerable !== undefined &&
      obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable
    ) {
      // Since we can't define a non-enumerable property on the object
      // we'll hijack one of the less-used non-enumerable properties to
      // save our hash on it. Since this is a function it will not show up in
      // `JSON.stringify` which is what we want.
      obj.propertyIsEnumerable = function () {
        return this.constructor.prototype.propertyIsEnumerable.apply(
          this,
          arguments
        );
      };
      obj.propertyIsEnumerable[UID_HASH_KEY] = hashed;
    } else if (obj.nodeType !== undefined) {
      // At this point we couldn't get the IE `uniqueID` to use as a hash
      // and we couldn't use a non-enumerable property to exploit the
      // dontEnum bug so we simply add the `UID_HASH_KEY` on the node
      // itself.
      obj[UID_HASH_KEY] = hashed;
    } else {
      throw new Error('Unable to set a non-enumerable property on object.');
    }

    return hashed;
  }

  // Get references to ES5 object methods.
  var isExtensible = Object.isExtensible;

  // True if Object.defineProperty works as expected. IE8 fails this test.
  var canDefineProperty = (function () {
    try {
      Object.defineProperty({}, '@', {});
      return true;
    } catch (e) {
      return false;
    }
  })();

  // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it
  // and avoid memory leaks from the IE cloneNode bug.
  function getIENodeHash(node) {
    if (node && node.nodeType > 0) {
      switch (node.nodeType) {
        case 1: // Element
          return node.uniqueID;
        case 9: // Document
          return node.documentElement && node.documentElement.uniqueID;
      }
    }
  }

  function valueOf(obj) {
    return obj.valueOf !== defaultValueOf && typeof obj.valueOf === 'function'
      ? obj.valueOf(obj)
      : obj;
  }

  function nextHash() {
    var nextHash = ++_objHashUID;
    if (_objHashUID & 0x40000000) {
      _objHashUID = 0;
    }
    return nextHash;
  }

  // If possible, use a WeakMap.
  var usingWeakMap = typeof WeakMap === 'function';
  var weakMap;
  if (usingWeakMap) {
    weakMap = new WeakMap();
  }

  var symbolMap = Object.create(null);

  var _objHashUID = 0;

  var UID_HASH_KEY = '__immutablehash__';
  if (typeof Symbol === 'function') {
    UID_HASH_KEY = Symbol(UID_HASH_KEY);
  }

  var STRING_HASH_CACHE_MIN_STRLEN = 16;
  var STRING_HASH_CACHE_MAX_SIZE = 255;
  var STRING_HASH_CACHE_SIZE = 0;
  var stringHashCache = {};

  var ToKeyedSequence = /*@__PURE__*/(function (KeyedSeq) {
    function ToKeyedSequence(indexed, useKeys) {
      this._iter = indexed;
      this._useKeys = useKeys;
      this.size = indexed.size;
    }

    if ( KeyedSeq ) ToKeyedSequence.__proto__ = KeyedSeq;
    ToKeyedSequence.prototype = Object.create( KeyedSeq && KeyedSeq.prototype );
    ToKeyedSequence.prototype.constructor = ToKeyedSequence;

    ToKeyedSequence.prototype.get = function get (key, notSetValue) {
      return this._iter.get(key, notSetValue);
    };

    ToKeyedSequence.prototype.has = function has (key) {
      return this._iter.has(key);
    };

    ToKeyedSequence.prototype.valueSeq = function valueSeq () {
      return this._iter.valueSeq();
    };

    ToKeyedSequence.prototype.reverse = function reverse () {
      var this$1$1 = this;

      var reversedSequence = reverseFactory(this, true);
      if (!this._useKeys) {
        reversedSequence.valueSeq = function () { return this$1$1._iter.toSeq().reverse(); };
      }
      return reversedSequence;
    };

    ToKeyedSequence.prototype.map = function map (mapper, context) {
      var this$1$1 = this;

      var mappedSequence = mapFactory(this, mapper, context);
      if (!this._useKeys) {
        mappedSequence.valueSeq = function () { return this$1$1._iter.toSeq().map(mapper, context); };
      }
      return mappedSequence;
    };

    ToKeyedSequence.prototype.__iterate = function __iterate (fn, reverse) {
      var this$1$1 = this;

      return this._iter.__iterate(function (v, k) { return fn(v, k, this$1$1); }, reverse);
    };

    ToKeyedSequence.prototype.__iterator = function __iterator (type, reverse) {
      return this._iter.__iterator(type, reverse);
    };

    return ToKeyedSequence;
  }(KeyedSeq));
  ToKeyedSequence.prototype[IS_ORDERED_SYMBOL] = true;

  var ToIndexedSequence = /*@__PURE__*/(function (IndexedSeq) {
    function ToIndexedSequence(iter) {
      this._iter = iter;
      this.size = iter.size;
    }

    if ( IndexedSeq ) ToIndexedSequence.__proto__ = IndexedSeq;
    ToIndexedSequence.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );
    ToIndexedSequence.prototype.constructor = ToIndexedSequence;

    ToIndexedSequence.prototype.includes = function includes (value) {
      return this._iter.includes(value);
    };

    ToIndexedSequence.prototype.__iterate = function __iterate (fn, reverse) {
      var this$1$1 = this;

      var i = 0;
      reverse && ensureSize(this);
      return this._iter.__iterate(
        function (v) { return fn(v, reverse ? this$1$1.size - ++i : i++, this$1$1); },
        reverse
      );
    };

    ToIndexedSequence.prototype.__iterator = function __iterator (type, reverse) {
      var this$1$1 = this;

      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      var i = 0;
      reverse && ensureSize(this);
      return new Iterator(function () {
        var step = iterator.next();
        return step.done
          ? step
          : iteratorValue(
              type,
              reverse ? this$1$1.size - ++i : i++,
              step.value,
              step
            );
      });
    };

    return ToIndexedSequence;
  }(IndexedSeq));

  var ToSetSequence = /*@__PURE__*/(function (SetSeq) {
    function ToSetSequence(iter) {
      this._iter = iter;
      this.size = iter.size;
    }

    if ( SetSeq ) ToSetSequence.__proto__ = SetSeq;
    ToSetSequence.prototype = Object.create( SetSeq && SetSeq.prototype );
    ToSetSequence.prototype.constructor = ToSetSequence;

    ToSetSequence.prototype.has = function has (key) {
      return this._iter.includes(key);
    };

    ToSetSequence.prototype.__iterate = function __iterate (fn, reverse) {
      var this$1$1 = this;

      return this._iter.__iterate(function (v) { return fn(v, v, this$1$1); }, reverse);
    };

    ToSetSequence.prototype.__iterator = function __iterator (type, reverse) {
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      return new Iterator(function () {
        var step = iterator.next();
        return step.done
          ? step
          : iteratorValue(type, step.value, step.value, step);
      });
    };

    return ToSetSequence;
  }(SetSeq));

  var FromEntriesSequence = /*@__PURE__*/(function (KeyedSeq) {
    function FromEntriesSequence(entries) {
      this._iter = entries;
      this.size = entries.size;
    }

    if ( KeyedSeq ) FromEntriesSequence.__proto__ = KeyedSeq;
    FromEntriesSequence.prototype = Object.create( KeyedSeq && KeyedSeq.prototype );
    FromEntriesSequence.prototype.constructor = FromEntriesSequence;

    FromEntriesSequence.prototype.entrySeq = function entrySeq () {
      return this._iter.toSeq();
    };

    FromEntriesSequence.prototype.__iterate = function __iterate (fn, reverse) {
      var this$1$1 = this;

      return this._iter.__iterate(function (entry) {
        // Check if entry exists first so array access doesn't throw for holes
        // in the parent iteration.
        if (entry) {
          validateEntry(entry);
          var indexedCollection = isCollection(entry);
          return fn(
            indexedCollection ? entry.get(1) : entry[1],
            indexedCollection ? entry.get(0) : entry[0],
            this$1$1
          );
        }
      }, reverse);
    };

    FromEntriesSequence.prototype.__iterator = function __iterator (type, reverse) {
      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
      return new Iterator(function () {
        while (true) {
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          var entry = step.value;
          // Check if entry exists first so array access doesn't throw for holes
          // in the parent iteration.
          if (entry) {
            validateEntry(entry);
            var indexedCollection = isCollection(entry);
            return iteratorValue(
              type,
              indexedCollection ? entry.get(0) : entry[0],
              indexedCollection ? entry.get(1) : entry[1],
              step
            );
          }
        }
      });
    };

    return FromEntriesSequence;
  }(KeyedSeq));

  ToIndexedSequence.prototype.cacheResult =
    ToKeyedSequence.prototype.cacheResult =
    ToSetSequence.prototype.cacheResult =
    FromEntriesSequence.prototype.cacheResult =
      cacheResultThrough;

  function flipFactory(collection) {
    var flipSequence = makeSequence(collection);
    flipSequence._iter = collection;
    flipSequence.size = collection.size;
    flipSequence.flip = function () { return collection; };
    flipSequence.reverse = function () {
      var reversedSequence = collection.reverse.apply(this); // super.reverse()
      reversedSequence.flip = function () { return collection.reverse(); };
      return reversedSequence;
    };
    flipSequence.has = function (key) { return collection.includes(key); };
    flipSequence.includes = function (key) { return collection.has(key); };
    flipSequence.cacheResult = cacheResultThrough;
    flipSequence.__iterateUncached = function (fn, reverse) {
      var this$1$1 = this;

      return collection.__iterate(function (v, k) { return fn(k, v, this$1$1) !== false; }, reverse);
    };
    flipSequence.__iteratorUncached = function (type, reverse) {
      if (type === ITERATE_ENTRIES) {
        var iterator = collection.__iterator(type, reverse);
        return new Iterator(function () {
          var step = iterator.next();
          if (!step.done) {
            var k = step.value[0];
            step.value[0] = step.value[1];
            step.value[1] = k;
          }
          return step;
        });
      }
      return collection.__iterator(
        type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES,
        reverse
      );
    };
    return flipSequence;
  }

  function mapFactory(collection, mapper, context) {
    var mappedSequence = makeSequence(collection);
    mappedSequence.size = collection.size;
    mappedSequence.has = function (key) { return collection.has(key); };
    mappedSequence.get = function (key, notSetValue) {
      var v = collection.get(key, NOT_SET);
      return v === NOT_SET
        ? notSetValue
        : mapper.call(context, v, key, collection);
    };
    mappedSequence.__iterateUncached = function (fn, reverse) {
      var this$1$1 = this;

      return collection.__iterate(
        function (v, k, c) { return fn(mapper.call(context, v, k, c), k, this$1$1) !== false; },
        reverse
      );
    };
    mappedSequence.__iteratorUncached = function (type, reverse) {
      var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);
      return new Iterator(function () {
        var step = iterator.next();
        if (step.done) {
          return step;
        }
        var entry = step.value;
        var key = entry[0];
        return iteratorValue(
          type,
          key,
          mapper.call(context, entry[1], key, collection),
          step
        );
      });
    };
    return mappedSequence;
  }

  function reverseFactory(collection, useKeys) {
    var this$1$1 = this;

    var reversedSequence = makeSequence(collection);
    reversedSequence._iter = collection;
    reversedSequence.size = collection.size;
    reversedSequence.reverse = function () { return collection; };
    if (collection.flip) {
      reversedSequence.flip = function () {
        var flipSequence = flipFactory(collection);
        flipSequence.reverse = function () { return collection.flip(); };
        return flipSequence;
      };
    }
    reversedSequence.get = function (key, notSetValue) { return collection.get(useKeys ? key : -1 - key, notSetValue); };
    reversedSequence.has = function (key) { return collection.has(useKeys ? key : -1 - key); };
    reversedSequence.includes = function (value) { return collection.includes(value); };
    reversedSequence.cacheResult = cacheResultThrough;
    reversedSequence.__iterate = function (fn, reverse) {
      var this$1$1 = this;

      var i = 0;
      reverse && ensureSize(collection);
      return collection.__iterate(
        function (v, k) { return fn(v, useKeys ? k : reverse ? this$1$1.size - ++i : i++, this$1$1); },
        !reverse
      );
    };
    reversedSequence.__iterator = function (type, reverse) {
      var i = 0;
      reverse && ensureSize(collection);
      var iterator = collection.__iterator(ITERATE_ENTRIES, !reverse);
      return new Iterator(function () {
        var step = iterator.next();
        if (step.done) {
          return step;
        }
        var entry = step.value;
        return iteratorValue(
          type,
          useKeys ? entry[0] : reverse ? this$1$1.size - ++i : i++,
          entry[1],
          step
        );
      });
    };
    return reversedSequence;
  }

  function filterFactory(collection, predicate, context, useKeys) {
    var filterSequence = makeSequence(collection);
    if (useKeys) {
      filterSequence.has = function (key) {
        var v = collection.get(key, NOT_SET);
        return v !== NOT_SET && !!predicate.call(context, v, key, collection);
      };
      filterSequence.get = function (key, notSetValue) {
        var v = collection.get(key, NOT_SET);
        return v !== NOT_SET && predicate.call(context, v, key, collection)
          ? v
          : notSetValue;
      };
    }
    filterSequence.__iterateUncached = function (fn, reverse) {
      var this$1$1 = this;

      var iterations = 0;
      collection.__iterate(function (v, k, c) {
        if (predicate.call(context, v, k, c)) {
          iterations++;
          return fn(v, useKeys ? k : iterations - 1, this$1$1);
        }
      }, reverse);
      return iterations;
    };
    filterSequence.__iteratorUncached = function (type, reverse) {
      var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);
      var iterations = 0;
      return new Iterator(function () {
        while (true) {
          var step = iterator.next();
          if (step.done) {
            return step;
          }
          var entry = step.value;
          var key = entry[0];
          var value = entry[1];
          if (predicate.call(context, value, key, collection)) {
            return iteratorValue(type, useKeys ? key : iterations++, value, step);
          }
        }
      });
    };
    return filterSequence;
  }

  function countByFactory(collection, grouper, context) {
    var groups = Map().asMutable();
    collection.__iterate(function (v, k) {
      groups.update(grouper.call(context, v, k, collection), 0, function (a) { return a + 1; });
    });
    return groups.asImmutable();
  }

  function groupByFactory(collection, grouper, context) {
    var isKeyedIter = isKeyed(collection);
    var groups = (isOrdered(collection) ? OrderedMap() : Map()).asMutable();
    collection.__iterate(function (v, k) {
      groups.update(
        grouper.call(context, v, k, collection),
        function (a) { return ((a = a || []), a.push(isKeyedIter ? [k, v] : v), a); }
      );
    });
    var coerce = collectionClass(collection);
    return groups.map(function (arr) { return reify(collection, coerce(arr)); }).asImmutable();
  }

  function sliceFactory(collection, begin, end, useKeys) {
    var originalSize = collection.size;

    if (wholeSlice(begin, end, originalSize)) {
      return collection;
    }

    var resolvedBegin = resolveBegin(begin, originalSize);
    var resolvedEnd = resolveEnd(end, originalSize);

    // begin or end will be NaN if they were provided as negative numbers and
    // this collection's size is unknown. In that case, cache first so there is
    // a known size and these do not resolve to NaN.
    if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) {
      return sliceFactory(collection.toSeq().cacheResult(), begin, end, useKeys);
    }

    // Note: resolvedEnd is undefined when the original sequence's length is
    // unknown and this slice did not supply an end and should contain all
    // elements after resolvedBegin.
    // In that case, resolvedSize will be NaN and sliceSize will remain undefined.
    var resolvedSize = resolvedEnd - resolvedBegin;
    var sliceSize;
    if (resolvedSize === resolvedSize) {
      sliceSize = resolvedSize < 0 ? 0 : resolvedSize;
    }

    var sliceSeq = makeSequence(collection);

    // If collection.size is undefined, the size of the realized sliceSeq is
    // unknown at this point unless the number of items to slice is 0
    sliceSeq.size =
      sliceSize === 0 ? sliceSize : (collection.size && sliceSize) || undefined;

    if (!useKeys && isSeq(collection) && sliceSize >= 0) {
      sliceSeq.get = function (index, notSetValue) {
        index = wrapIndex(this, index);
        return index >= 0 && index < sliceSize
          ? collection.get(index + resolvedBegin, notSetValue)
          : notSetValue;
      };
    }

    sliceSeq.__iterateUncached = function (fn, reverse) {
      var this$1$1 = this;

      if (sliceSize === 0) {
        return 0;
      }
      if (reverse) {
        return this.cacheResult().__iterate(fn, reverse);
      }
      var skipped = 0;
      var isSkipping = true;
      var iterations = 0;
      collection.__iterate(function (v, k) {
        if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {
          iterations++;
          return (
            fn(v, useKeys ? k : iterations - 1, this$1$1) !== false &&
            iterations !== sliceSize
          );
        }
      });
      return iterations;
    };

    sliceSeq.__iteratorUncached = function (type, reverse) {
      if (sliceSize !== 0 && reverse) {
        return this.cacheResult().__iterator(type, reverse);
      }
      // Don't bother instantiating parent iterator if taking 0.
      if (sliceSize === 0) {
        return new Iterator(iteratorDone);
      }
      var iterator = collection.__iterator(type, reverse);
      var skipped = 0;
      var iterations = 0;
      return new Iterator(function () {
        while (skipped++ < resolvedBegin) {
          iterator.next();
        }
        if (++iterations > sliceSize) {
          return iteratorDone();
        }
        var step = iterator.next();
        if (useKeys || type === ITERATE_VALUES || step.done) {
          return step;
        }
        if (type === ITERATE_KEYS) {
          return iteratorValue(type, iterations - 1, undefined, step);
        }
        return iteratorValue(type, iterations - 1, step.value[1], step);
      });
    };

    return sliceSeq;
  }

  function takeWhileFactory(collection, predicate, context) {
    var takeSequence = makeSequence(collection);
    takeSequence.__iterateUncached = function (fn, reverse) {
      var this$1$1 = this;

      if (reverse) {
        return this.cacheResult().__iterate(fn, reverse);
      }
      var iterations = 0;
      collection.__iterate(
        function (v, k, c) { return predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$1$1); }
      );
      return iterations;
    };
    takeSequence.__iteratorUncached = function (type, reverse) {
      var this$1$1 = this;

      if (reverse) {
        return this.cacheResult().__iterator(type, reverse);
      }
      var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);
      var iterating = true;
      return new Iterator(function () {
        if (!iterating) {
          return iteratorDone();
        }
        var step = iterator.next();
        if (step.done) {
          return step;
        }
        var entry = step.value;
        var k = entry[0];
        var v = entry[1];
        if (!predicate.call(context, v, k, this$1$1)) {
          iterating = false;
          return iteratorDone();
        }
        return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step);
      });
    };
    return takeSequence;
  }

  function skipWhileFactory(collection, predicate, context, useKeys) {
    var skipSequence = makeSequence(collection);
    skipSequence.__iterateUncached = function (fn, reverse) {
      var this$1$1 = this;

      if (reverse) {
        return this.cacheResult().__iterate(fn, reverse);
      }
      var isSkipping = true;
      var iterations = 0;
      collection.__iterate(function (v, k, c) {
        if (!(isSkipping && (isSkipping = predicate.call(context, v, k, c)))) {
          iterations++;
          return fn(v, useKeys ? k : iterations - 1, this$1$1);
        }
      });
      return iterations;
    };
    skipSequence.__iteratorUncached = function (type, reverse) {
      var this$1$1 = this;

      if (reverse) {
        return this.cacheResult().__iterator(type, reverse);
      }
      var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);
      var skipping = true;
      var iterations = 0;
      return new Iterator(function () {
        var step;
        var k;
        var v;
        do {
          step = iterator.next();
          if (step.done) {
            if (useKeys || type === ITERATE_VALUES) {
              return step;
            }
            if (type === ITERATE_KEYS) {
              return iteratorValue(type, iterations++, undefined, step);
            }
            return iteratorValue(type, iterations++, step.value[1], step);
          }
          var entry = step.value;
          k = entry[0];
          v = entry[1];
          skipping && (skipping = predicate.call(context, v, k, this$1$1));
        } while (skipping);
        return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step);
      });
    };
    return skipSequence;
  }

  function concatFactory(collection, values) {
    var isKeyedCollection = isKeyed(collection);
    var iters = [collection]
      .concat(values)
      .map(function (v) {
        if (!isCollection(v)) {
          v = isKeyedCollection
            ? keyedSeqFromValue(v)
            : indexedSeqFromValue(Array.isArray(v) ? v : [v]);
        } else if (isKeyedCollection) {
          v = KeyedCollection(v);
        }
        return v;
      })
      .filter(function (v) { return v.size !== 0; });

    if (iters.length === 0) {
      return collection;
    }

    if (iters.length === 1) {
      var singleton = iters[0];
      if (
        singleton === collection ||
        (isKeyedCollection && isKeyed(singleton)) ||
        (isIndexed(collection) && isIndexed(singleton))
      ) {
        return singleton;
      }
    }

    var concatSeq = new ArraySeq(iters);
    if (isKeyedCollection) {
      concatSeq = concatSeq.toKeyedSeq();
    } else if (!isIndexed(collection)) {
      concatSeq = concatSeq.toSetSeq();
    }
    concatSeq = concatSeq.flatten(true);
    concatSeq.size = iters.reduce(function (sum, seq) {
      if (sum !== undefined) {
        var size = seq.size;
        if (size !== undefined) {
          return sum + size;
        }
      }
    }, 0);
    return concatSeq;
  }

  function flattenFactory(collection, depth, useKeys) {
    var flatSequence = makeSequence(collection);
    flatSequence.__iterateUncached = function (fn, reverse) {
      if (reverse) {
        return this.cacheResult().__iterate(fn, reverse);
      }
      var iterations = 0;
      var stopped = false;
      function flatDeep(iter, currentDepth) {
        iter.__iterate(function (v, k) {
          if ((!depth || currentDepth < depth) && isCollection(v)) {
            flatDeep(v, currentDepth + 1);
          } else {
            iterations++;
            if (fn(v, useKeys ? k : iterations - 1, flatSequence) === false) {
              stopped = true;
            }
          }
          return !stopped;
        }, reverse);
      }
      flatDeep(collection, 0);
      return iterations;
    };
    flatSequence.__iteratorUncached = function (type, reverse) {
      if (reverse) {
        return this.cacheResult().__iterator(type, reverse);
      }
      var iterator = collection.__iterator(type, reverse);
      var stack = [];
      var iterations = 0;
      return new Iterator(function () {
        while (iterator) {
          var step = iterator.next();
          if (step.done !== false) {
            iterator = stack.pop();
            continue;
          }
          var v = step.value;
          if (type === ITERATE_ENTRIES) {
            v = v[1];
          }
          if ((!depth || stack.length < depth) && isCollection(v)) {
            stack.push(iterator);
            iterator = v.__iterator(type, reverse);
          } else {
            return useKeys ? step : iteratorValue(type, iterations++, v, step);
          }
        }
        return iteratorDone();
      });
    };
    return flatSequence;
  }

  function flatMapFactory(collection, mapper, context) {
    var coerce = collectionClass(collection);
    return collection
      .toSeq()
      .map(function (v, k) { return coerce(mapper.call(context, v, k, collection)); })
      .flatten(true);
  }

  function interposeFactory(collection, separator) {
    var interposedSequence = makeSequence(collection);
    interposedSequence.size = collection.size && collection.size * 2 - 1;
    interposedSequence.__iterateUncached = function (fn, reverse) {
      var this$1$1 = this;

      var iterations = 0;
      collection.__iterate(
        function (v) { return (!iterations || fn(separator, iterations++, this$1$1) !== false) &&
          fn(v, iterations++, this$1$1) !== false; },
        reverse
      );
      return iterations;
    };
    interposedSequence.__iteratorUncached = function (type, reverse) {
      var iterator = collection.__iterator(ITERATE_VALUES, reverse);
      var iterations = 0;
      var step;
      return new Iterator(function () {
        if (!step || iterations % 2) {
          step = iterator.next();
          if (step.done) {
            return step;
          }
        }
        return iterations % 2
          ? iteratorValue(type, iterations++, separator)
          : iteratorValue(type, iterations++, step.value, step);
      });
    };
    return interposedSequence;
  }

  function sortFactory(collection, comparator, mapper) {
    if (!comparator) {
      comparator = defaultComparator;
    }
    var isKeyedCollection = isKeyed(collection);
    var index = 0;
    var entries = collection
      .toSeq()
      .map(function (v, k) { return [k, v, index++, mapper ? mapper(v, k, collection) : v]; })
      .valueSeq()
      .toArray();
    entries
      .sort(function (a, b) { return comparator(a[3], b[3]) || a[2] - b[2]; })
      .forEach(
        isKeyedCollection
          ? function (v, i) {
              entries[i].length = 2;
            }
          : function (v, i) {
              entries[i] = v[1];
            }
      );
    return isKeyedCollection
      ? KeyedSeq(entries)
      : isIndexed(collection)
      ? IndexedSeq(entries)
      : SetSeq(entries);
  }

  function maxFactory(collection, comparator, mapper) {
    if (!comparator) {
      comparator = defaultComparator;
    }
    if (mapper) {
      var entry = collection
        .toSeq()
        .map(function (v, k) { return [v, mapper(v, k, collection)]; })
        .reduce(function (a, b) { return (maxCompare(comparator, a[1], b[1]) ? b : a); });
      return entry && entry[0];
    }
    return collection.reduce(function (a, b) { return (maxCompare(comparator, a, b) ? b : a); });
  }

  function maxCompare(comparator, a, b) {
    var comp = comparator(b, a);
    // b is considered the new max if the comparator declares them equal, but
    // they are not equal and b is in fact a nullish value.
    return (
      (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) ||
      comp > 0
    );
  }

  function zipWithFactory(keyIter, zipper, iters, zipAll) {
    var zipSequence = makeSequence(keyIter);
    var sizes = new ArraySeq(iters).map(function (i) { return i.size; });
    zipSequence.size = zipAll ? sizes.max() : sizes.min();
    // Note: this a generic base implementation of __iterate in terms of
    // __iterator which may be more generically useful in the future.
    zipSequence.__iterate = function (fn, reverse) {
      /* generic:
      var iterator = this.__iterator(ITERATE_ENTRIES, reverse);
      var step;
      var iterations = 0;
      while (!(step = iterator.next()).done) {
        iterations++;
        if (fn(step.value[1], step.value[0], this) === false) {
          break;
        }
      }
      return iterations;
      */
      // indexed:
      var iterator = this.__iterator(ITERATE_VALUES, reverse);
      var step;
      var iterations = 0;
      while (!(step = iterator.next()).done) {
        if (fn(step.value, iterations++, this) === false) {
          break;
        }
      }
      return iterations;
    };
    zipSequence.__iteratorUncached = function (type, reverse) {
      var iterators = iters.map(
        function (i) { return ((i = Collection(i)), getIterator(reverse ? i.reverse() : i)); }
      );
      var iterations = 0;
      var isDone = false;
      return new Iterator(function () {
        var steps;
        if (!isDone) {
          steps = iterators.map(function (i) { return i.next(); });
          isDone = zipAll ? steps.every(function (s) { return s.done; }) : steps.some(function (s) { return s.done; });
        }
        if (isDone) {
          return iteratorDone();
        }
        return iteratorValue(
          type,
          iterations++,
          zipper.apply(
            null,
            steps.map(function (s) { return s.value; })
          )
        );
      });
    };
    return zipSequence;
  }

  // #pragma Helper Functions

  function reify(iter, seq) {
    return iter === seq ? iter : isSeq(iter) ? seq : iter.constructor(seq);
  }

  function validateEntry(entry) {
    if (entry !== Object(entry)) {
      throw new TypeError('Expected [K, V] tuple: ' + entry);
    }
  }

  function collectionClass(collection) {
    return isKeyed(collection)
      ? KeyedCollection
      : isIndexed(collection)
      ? IndexedCollection
      : SetCollection;
  }

  function makeSequence(collection) {
    return Object.create(
      (isKeyed(collection)
        ? KeyedSeq
        : isIndexed(collection)
        ? IndexedSeq
        : SetSeq
      ).prototype
    );
  }

  function cacheResultThrough() {
    if (this._iter.cacheResult) {
      this._iter.cacheResult();
      this.size = this._iter.size;
      return this;
    }
    return Seq.prototype.cacheResult.call(this);
  }

  function defaultComparator(a, b) {
    if (a === undefined && b === undefined) {
      return 0;
    }

    if (a === undefined) {
      return 1;
    }

    if (b === undefined) {
      return -1;
    }

    return a > b ? 1 : a < b ? -1 : 0;
  }

  function arrCopy(arr, offset) {
    offset = offset || 0;
    var len = Math.max(0, arr.length - offset);
    var newArr = new Array(len);
    for (var ii = 0; ii < len; ii++) {
      newArr[ii] = arr[ii + offset];
    }
    return newArr;
  }

  function invariant(condition, error) {
    if (!condition) { throw new Error(error); }
  }

  function assertNotInfinite(size) {
    invariant(
      size !== Infinity,
      'Cannot perform this action with an infinite size.'
    );
  }

  function coerceKeyPath(keyPath) {
    if (isArrayLike(keyPath) && typeof keyPath !== 'string') {
      return keyPath;
    }
    if (isOrdered(keyPath)) {
      return keyPath.toArray();
    }
    throw new TypeError(
      'Invalid keyPath: expected Ordered Collection or Array: ' + keyPath
    );
  }

  var toString = Object.prototype.toString;

  function isPlainObject(value) {
    // The base prototype's toString deals with Argument objects and native namespaces like Math
    if (
      !value ||
      typeof value !== 'object' ||
      toString.call(value) !== '[object Object]'
    ) {
      return false;
    }

    var proto = Object.getPrototypeOf(value);
    if (proto === null) {
      return true;
    }

    // Iteratively going up the prototype chain is needed for cross-realm environments (differing contexts, iframes, etc)
    var parentProto = proto;
    var nextProto = Object.getPrototypeOf(proto);
    while (nextProto !== null) {
      parentProto = nextProto;
      nextProto = Object.getPrototypeOf(parentProto);
    }
    return parentProto === proto;
  }

  /**
   * Returns true if the value is a potentially-persistent data structure, either
   * provided by Immutable.js or a plain Array or Object.
   */
  function isDataStructure(value) {
    return (
      typeof value === 'object' &&
      (isImmutable(value) || Array.isArray(value) || isPlainObject(value))
    );
  }

  function quoteString(value) {
    try {
      return typeof value === 'string' ? JSON.stringify(value) : String(value);
    } catch (_ignoreError) {
      return JSON.stringify(value);
    }
  }

  function has(collection, key) {
    return isImmutable(collection)
      ? collection.has(key)
      : isDataStructure(collection) && hasOwnProperty.call(collection, key);
  }

  function get(collection, key, notSetValue) {
    return isImmutable(collection)
      ? collection.get(key, notSetValue)
      : !has(collection, key)
      ? notSetValue
      : typeof collection.get === 'function'
      ? collection.get(key)
      : collection[key];
  }

  function shallowCopy(from) {
    if (Array.isArray(from)) {
      return arrCopy(from);
    }
    var to = {};
    for (var key in from) {
      if (hasOwnProperty.call(from, key)) {
        to[key] = from[key];
      }
    }
    return to;
  }

  function remove(collection, key) {
    if (!isDataStructure(collection)) {
      throw new TypeError(
        'Cannot update non-data-structure value: ' + collection
      );
    }
    if (isImmutable(collection)) {
      if (!collection.remove) {
        throw new TypeError(
          'Cannot update immutable value without .remove() method: ' + collection
        );
      }
      return collection.remove(key);
    }
    if (!hasOwnProperty.call(collection, key)) {
      return collection;
    }
    var collectionCopy = shallowCopy(collection);
    if (Array.isArray(collectionCopy)) {
      collectionCopy.splice(key, 1);
    } else {
      delete collectionCopy[key];
    }
    return collectionCopy;
  }

  function set(collection, key, value) {
    if (!isDataStructure(collection)) {
      throw new TypeError(
        'Cannot update non-data-structure value: ' + collection
      );
    }
    if (isImmutable(collection)) {
      if (!collection.set) {
        throw new TypeError(
          'Cannot update immutable value without .set() method: ' + collection
        );
      }
      return collection.set(key, value);
    }
    if (hasOwnProperty.call(collection, key) && value === collection[key]) {
      return collection;
    }
    var collectionCopy = shallowCopy(collection);
    collectionCopy[key] = value;
    return collectionCopy;
  }

  function updateIn$1(collection, keyPath, notSetValue, updater) {
    if (!updater) {
      updater = notSetValue;
      notSetValue = undefined;
    }
    var updatedValue = updateInDeeply(
      isImmutable(collection),
      collection,
      coerceKeyPath(keyPath),
      0,
      notSetValue,
      updater
    );
    return updatedValue === NOT_SET ? notSetValue : updatedValue;
  }

  function updateInDeeply(
    inImmutable,
    existing,
    keyPath,
    i,
    notSetValue,
    updater
  ) {
    var wasNotSet = existing === NOT_SET;
    if (i === keyPath.length) {
      var existingValue = wasNotSet ? notSetValue : existing;
      var newValue = updater(existingValue);
      return newValue === existingValue ? existing : newValue;
    }
    if (!wasNotSet && !isDataStructure(existing)) {
      throw new TypeError(
        'Cannot update within non-data-structure value in path [' +
          keyPath.slice(0, i).map(quoteString) +
          ']: ' +
          existing
      );
    }
    var key = keyPath[i];
    var nextExisting = wasNotSet ? NOT_SET : get(existing, key, NOT_SET);
    var nextUpdated = updateInDeeply(
      nextExisting === NOT_SET ? inImmutable : isImmutable(nextExisting),
      nextExisting,
      keyPath,
      i + 1,
      notSetValue,
      updater
    );
    return nextUpdated === nextExisting
      ? existing
      : nextUpdated === NOT_SET
      ? remove(existing, key)
      : set(
          wasNotSet ? (inImmutable ? emptyMap() : {}) : existing,
          key,
          nextUpdated
        );
  }

  function setIn$1(collection, keyPath, value) {
    return updateIn$1(collection, keyPath, NOT_SET, function () { return value; });
  }

  function setIn(keyPath, v) {
    return setIn$1(this, keyPath, v);
  }

  function removeIn(collection, keyPath) {
    return updateIn$1(collection, keyPath, function () { return NOT_SET; });
  }

  function deleteIn(keyPath) {
    return removeIn(this, keyPath);
  }

  function update$1(collection, key, notSetValue, updater) {
    return updateIn$1(collection, [key], notSetValue, updater);
  }

  function update(key, notSetValue, updater) {
    return arguments.length === 1
      ? key(this)
      : update$1(this, key, notSetValue, updater);
  }

  function updateIn(keyPath, notSetValue, updater) {
    return updateIn$1(this, keyPath, notSetValue, updater);
  }

  function merge$1() {
    var iters = [], len = arguments.length;
    while ( len-- ) iters[ len ] = arguments[ len ];

    return mergeIntoKeyedWith(this, iters);
  }

  function mergeWith$1(merger) {
    var iters = [], len = arguments.length - 1;
    while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];

    if (typeof merger !== 'function') {
      throw new TypeError('Invalid merger function: ' + merger);
    }
    return mergeIntoKeyedWith(this, iters, merger);
  }

  function mergeIntoKeyedWith(collection, collections, merger) {
    var iters = [];
    for (var ii = 0; ii < collections.length; ii++) {
      var collection$1 = KeyedCollection(collections[ii]);
      if (collection$1.size !== 0) {
        iters.push(collection$1);
      }
    }
    if (iters.length === 0) {
      return collection;
    }
    if (
      collection.toSeq().size === 0 &&
      !collection.__ownerID &&
      iters.length === 1
    ) {
      return collection.constructor(iters[0]);
    }
    return collection.withMutations(function (collection) {
      var mergeIntoCollection = merger
        ? function (value, key) {
            update$1(collection, key, NOT_SET, function (oldVal) { return oldVal === NOT_SET ? value : merger(oldVal, value, key); }
            );
          }
        : function (value, key) {
            collection.set(key, value);
          };
      for (var ii = 0; ii < iters.length; ii++) {
        iters[ii].forEach(mergeIntoCollection);
      }
    });
  }

  function merge(collection) {
    var sources = [], len = arguments.length - 1;
    while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ];

    return mergeWithSources(collection, sources);
  }

  function mergeWith(merger, collection) {
    var sources = [], len = arguments.length - 2;
    while ( len-- > 0 ) sources[ len ] = arguments[ len + 2 ];

    return mergeWithSources(collection, sources, merger);
  }

  function mergeDeep$1(collection) {
    var sources = [], len = arguments.length - 1;
    while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ];

    return mergeDeepWithSources(collection, sources);
  }

  function mergeDeepWith$1(merger, collection) {
    var sources = [], len = arguments.length - 2;
    while ( len-- > 0 ) sources[ len ] = arguments[ len + 2 ];

    return mergeDeepWithSources(collection, sources, merger);
  }

  function mergeDeepWithSources(collection, sources, merger) {
    return mergeWithSources(collection, sources, deepMergerWith(merger));
  }

  function mergeWithSources(collection, sources, merger) {
    if (!isDataStructure(collection)) {
      throw new TypeError(
        'Cannot merge into non-data-structure value: ' + collection
      );
    }
    if (isImmutable(collection)) {
      return typeof merger === 'function' && collection.mergeWith
        ? collection.mergeWith.apply(collection, [ merger ].concat( sources ))
        : collection.merge
        ? collection.merge.apply(collection, sources)
        : collection.concat.apply(collection, sources);
    }
    var isArray = Array.isArray(collection);
    var merged = collection;
    var Collection = isArray ? IndexedCollection : KeyedCollection;
    var mergeItem = isArray
      ? function (value) {
          // Copy on write
          if (merged === collection) {
            merged = shallowCopy(merged);
          }
          merged.push(value);
        }
      : function (value, key) {
          var hasVal = hasOwnProperty.call(merged, key);
          var nextVal =
            hasVal && merger ? merger(merged[key], value, key) : value;
          if (!hasVal || nextVal !== merged[key]) {
            // Copy on write
            if (merged === collection) {
              merged = shallowCopy(merged);
            }
            merged[key] = nextVal;
          }
        };
    for (var i = 0; i < sources.length; i++) {
      Collection(sources[i]).forEach(mergeItem);
    }
    return merged;
  }

  function deepMergerWith(merger) {
    function deepMerger(oldValue, newValue, key) {
      return isDataStructure(oldValue) &&
        isDataStructure(newValue) &&
        areMergeable(oldValue, newValue)
        ? mergeWithSources(oldValue, [newValue], deepMerger)
        : merger
        ? merger(oldValue, newValue, key)
        : newValue;
    }
    return deepMerger;
  }

  /**
   * It's unclear what the desired behavior is for merging two collections that
   * fall into separate categories between keyed, indexed, or set-like, so we only
   * consider them mergeable if they fall into the same category.
   */
  function areMergeable(oldDataStructure, newDataStructure) {
    var oldSeq = Seq(oldDataStructure);
    var newSeq = Seq(newDataStructure);
    // This logic assumes that a sequence can only fall into one of the three
    // categories mentioned above (since there's no `isSetLike()` method).
    return (
      isIndexed(oldSeq) === isIndexed(newSeq) &&
      isKeyed(oldSeq) === isKeyed(newSeq)
    );
  }

  function mergeDeep() {
    var iters = [], len = arguments.length;
    while ( len-- ) iters[ len ] = arguments[ len ];

    return mergeDeepWithSources(this, iters);
  }

  function mergeDeepWith(merger) {
    var iters = [], len = arguments.length - 1;
    while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];

    return mergeDeepWithSources(this, iters, merger);
  }

  function mergeIn(keyPath) {
    var iters = [], len = arguments.length - 1;
    while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];

    return updateIn$1(this, keyPath, emptyMap(), function (m) { return mergeWithSources(m, iters); });
  }

  function mergeDeepIn(keyPath) {
    var iters = [], len = arguments.length - 1;
    while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];

    return updateIn$1(this, keyPath, emptyMap(), function (m) { return mergeDeepWithSources(m, iters); }
    );
  }

  function withMutations(fn) {
    var mutable = this.asMutable();
    fn(mutable);
    return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this;
  }

  function asMutable() {
    return this.__ownerID ? this : this.__ensureOwner(new OwnerID());
  }

  function asImmutable() {
    return this.__ensureOwner();
  }

  function wasAltered() {
    return this.__altered;
  }

  var Map = /*@__PURE__*/(function (KeyedCollection) {
    function Map(value) {
      return value === undefined || value === null
        ? emptyMap()
        : isMap(value) && !isOrdered(value)
        ? value
        : emptyMap().withMutations(function (map) {
            var iter = KeyedCollection(value);
            assertNotInfinite(iter.size);
            iter.forEach(function (v, k) { return map.set(k, v); });
          });
    }

    if ( KeyedCollection ) Map.__proto__ = KeyedCollection;
    Map.prototype = Object.create( KeyedCollection && KeyedCollection.prototype );
    Map.prototype.constructor = Map;

    Map.of = function of () {
      var keyValues = [], len = arguments.length;
      while ( len-- ) keyValues[ len ] = arguments[ len ];

      return emptyMap().withMutations(function (map) {
        for (var i = 0; i < keyValues.length; i += 2) {
          if (i + 1 >= keyValues.length) {
            throw new Error('Missing value for key: ' + keyValues[i]);
          }
          map.set(keyValues[i], keyValues[i + 1]);
        }
      });
    };

    Map.prototype.toString = function toString () {
      return this.__toString('Map {', '}');
    };

    // @pragma Access

    Map.prototype.get = function get (k, notSetValue) {
      return this._root
        ? this._root.get(0, undefined, k, notSetValue)
        : notSetValue;
    };

    // @pragma Modification

    Map.prototype.set = function set (k, v) {
      return updateMap(this, k, v);
    };

    Map.prototype.remove = function remove (k) {
      return updateMap(this, k, NOT_SET);
    };

    Map.prototype.deleteAll = function deleteAll (keys) {
      var collection = Collection(keys);

      if (collection.size === 0) {
        return this;
      }

      return this.withMutations(function (map) {
        collection.forEach(function (key) { return map.remove(key); });
      });
    };

    Map.prototype.clear = function clear () {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = 0;
        this._root = null;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return emptyMap();
    };

    // @pragma Composition

    Map.prototype.sort = function sort (comparator) {
      // Late binding
      return OrderedMap(sortFactory(this, comparator));
    };

    Map.prototype.sortBy = function sortBy (mapper, comparator) {
      // Late binding
      return OrderedMap(sortFactory(this, comparator, mapper));
    };

    Map.prototype.map = function map (mapper, context) {
      var this$1$1 = this;

      return this.withMutations(function (map) {
        map.forEach(function (value, key) {
          map.set(key, mapper.call(context, value, key, this$1$1));
        });
      });
    };

    // @pragma Mutability

    Map.prototype.__iterator = function __iterator (type, reverse) {
      return new MapIterator(this, type, reverse);
    };

    Map.prototype.__iterate = function __iterate (fn, reverse) {
      var this$1$1 = this;

      var iterations = 0;
      this._root &&
        this._root.iterate(function (entry) {
          iterations++;
          return fn(entry[1], entry[0], this$1$1);
        }, reverse);
      return iterations;
    };

    Map.prototype.__ensureOwner = function __ensureOwner (ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      if (!ownerID) {
        if (this.size === 0) {
          return emptyMap();
        }
        this.__ownerID = ownerID;
        this.__altered = false;
        return this;
      }
      return makeMap(this.size, this._root, ownerID, this.__hash);
    };

    return Map;
  }(KeyedCollection));

  Map.isMap = isMap;

  var MapPrototype = Map.prototype;
  MapPrototype[IS_MAP_SYMBOL] = true;
  MapPrototype[DELETE] = MapPrototype.remove;
  MapPrototype.removeAll = MapPrototype.deleteAll;
  MapPrototype.setIn = setIn;
  MapPrototype.removeIn = MapPrototype.deleteIn = deleteIn;
  MapPrototype.update = update;
  MapPrototype.updateIn = updateIn;
  MapPrototype.merge = MapPrototype.concat = merge$1;
  MapPrototype.mergeWith = mergeWith$1;
  MapPrototype.mergeDeep = mergeDeep;
  MapPrototype.mergeDeepWith = mergeDeepWith;
  MapPrototype.mergeIn = mergeIn;
  MapPrototype.mergeDeepIn = mergeDeepIn;
  MapPrototype.withMutations = withMutations;
  MapPrototype.wasAltered = wasAltered;
  MapPrototype.asImmutable = asImmutable;
  MapPrototype['@@transducer/init'] = MapPrototype.asMutable = asMutable;
  MapPrototype['@@transducer/step'] = function (result, arr) {
    return result.set(arr[0], arr[1]);
  };
  MapPrototype['@@transducer/result'] = function (obj) {
    return obj.asImmutable();
  };

  // #pragma Trie Nodes

  var ArrayMapNode = function ArrayMapNode(ownerID, entries) {
    this.ownerID = ownerID;
    this.entries = entries;
  };

  ArrayMapNode.prototype.get = function get (shift, keyHash, key, notSetValue) {
    var entries = this.entries;
    for (var ii = 0, len = entries.length; ii < len; ii++) {
      if (is(key, entries[ii][0])) {
        return entries[ii][1];
      }
    }
    return notSetValue;
  };

  ArrayMapNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
    var removed = value === NOT_SET;

    var entries = this.entries;
    var idx = 0;
    var len = entries.length;
    for (; idx < len; idx++) {
      if (is(key, entries[idx][0])) {
        break;
      }
    }
    var exists = idx < len;

    if (exists ? entries[idx][1] === value : removed) {
      return this;
    }

    SetRef(didAlter);
    (removed || !exists) && SetRef(didChangeSize);

    if (removed && entries.length === 1) {
      return; // undefined
    }

    if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {
      return createNodes(ownerID, entries, key, value);
    }

    var isEditable = ownerID && ownerID === this.ownerID;
    var newEntries = isEditable ? entries : arrCopy(entries);

    if (exists) {
      if (removed) {
        idx === len - 1
          ? newEntries.pop()
          : (newEntries[idx] = newEntries.pop());
      } else {
        newEntries[idx] = [key, value];
      }
    } else {
      newEntries.push([key, value]);
    }

    if (isEditable) {
      this.entries = newEntries;
      return this;
    }

    return new ArrayMapNode(ownerID, newEntries);
  };

  var BitmapIndexedNode = function BitmapIndexedNode(ownerID, bitmap, nodes) {
    this.ownerID = ownerID;
    this.bitmap = bitmap;
    this.nodes = nodes;
  };

  BitmapIndexedNode.prototype.get = function get (shift, keyHash, key, notSetValue) {
    if (keyHash === undefined) {
      keyHash = hash(key);
    }
    var bit = 1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK);
    var bitmap = this.bitmap;
    return (bitmap & bit) === 0
      ? notSetValue
      : this.nodes[popCount(bitmap & (bit - 1))].get(
          shift + SHIFT,
          keyHash,
          key,
          notSetValue
        );
  };

  BitmapIndexedNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
    if (keyHash === undefined) {
      keyHash = hash(key);
    }
    var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
    var bit = 1 << keyHashFrag;
    var bitmap = this.bitmap;
    var exists = (bitmap & bit) !== 0;

    if (!exists && value === NOT_SET) {
      return this;
    }

    var idx = popCount(bitmap & (bit - 1));
    var nodes = this.nodes;
    var node = exists ? nodes[idx] : undefined;
    var newNode = updateNode(
      node,
      ownerID,
      shift + SHIFT,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    );

    if (newNode === node) {
      return this;
    }

    if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {
      return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);
    }

    if (
      exists &&
      !newNode &&
      nodes.length === 2 &&
      isLeafNode(nodes[idx ^ 1])
    ) {
      return nodes[idx ^ 1];
    }

    if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {
      return newNode;
    }

    var isEditable = ownerID && ownerID === this.ownerID;
    var newBitmap = exists ? (newNode ? bitmap : bitmap ^ bit) : bitmap | bit;
    var newNodes = exists
      ? newNode
        ? setAt(nodes, idx, newNode, isEditable)
        : spliceOut(nodes, idx, isEditable)
      : spliceIn(nodes, idx, newNode, isEditable);

    if (isEditable) {
      this.bitmap = newBitmap;
      this.nodes = newNodes;
      return this;
    }

    return new BitmapIndexedNode(ownerID, newBitmap, newNodes);
  };

  var HashArrayMapNode = function HashArrayMapNode(ownerID, count, nodes) {
    this.ownerID = ownerID;
    this.count = count;
    this.nodes = nodes;
  };

  HashArrayMapNode.prototype.get = function get (shift, keyHash, key, notSetValue) {
    if (keyHash === undefined) {
      keyHash = hash(key);
    }
    var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
    var node = this.nodes[idx];
    return node
      ? node.get(shift + SHIFT, keyHash, key, notSetValue)
      : notSetValue;
  };

  HashArrayMapNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
    if (keyHash === undefined) {
      keyHash = hash(key);
    }
    var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
    var removed = value === NOT_SET;
    var nodes = this.nodes;
    var node = nodes[idx];

    if (removed && !node) {
      return this;
    }

    var newNode = updateNode(
      node,
      ownerID,
      shift + SHIFT,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    );
    if (newNode === node) {
      return this;
    }

    var newCount = this.count;
    if (!node) {
      newCount++;
    } else if (!newNode) {
      newCount--;
      if (newCount < MIN_HASH_ARRAY_MAP_SIZE) {
        return packNodes(ownerID, nodes, newCount, idx);
      }
    }

    var isEditable = ownerID && ownerID === this.ownerID;
    var newNodes = setAt(nodes, idx, newNode, isEditable);

    if (isEditable) {
      this.count = newCount;
      this.nodes = newNodes;
      return this;
    }

    return new HashArrayMapNode(ownerID, newCount, newNodes);
  };

  var HashCollisionNode = function HashCollisionNode(ownerID, keyHash, entries) {
    this.ownerID = ownerID;
    this.keyHash = keyHash;
    this.entries = entries;
  };

  HashCollisionNode.prototype.get = function get (shift, keyHash, key, notSetValue) {
    var entries = this.entries;
    for (var ii = 0, len = entries.length; ii < len; ii++) {
      if (is(key, entries[ii][0])) {
        return entries[ii][1];
      }
    }
    return notSetValue;
  };

  HashCollisionNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
    if (keyHash === undefined) {
      keyHash = hash(key);
    }

    var removed = value === NOT_SET;

    if (keyHash !== this.keyHash) {
      if (removed) {
        return this;
      }
      SetRef(didAlter);
      SetRef(didChangeSize);
      return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);
    }

    var entries = this.entries;
    var idx = 0;
    var len = entries.length;
    for (; idx < len; idx++) {
      if (is(key, entries[idx][0])) {
        break;
      }
    }
    var exists = idx < len;

    if (exists ? entries[idx][1] === value : removed) {
      return this;
    }

    SetRef(didAlter);
    (removed || !exists) && SetRef(didChangeSize);

    if (removed && len === 2) {
      return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);
    }

    var isEditable = ownerID && ownerID === this.ownerID;
    var newEntries = isEditable ? entries : arrCopy(entries);

    if (exists) {
      if (removed) {
        idx === len - 1
          ? newEntries.pop()
          : (newEntries[idx] = newEntries.pop());
      } else {
        newEntries[idx] = [key, value];
      }
    } else {
      newEntries.push([key, value]);
    }

    if (isEditable) {
      this.entries = newEntries;
      return this;
    }

    return new HashCollisionNode(ownerID, this.keyHash, newEntries);
  };

  var ValueNode = function ValueNode(ownerID, keyHash, entry) {
    this.ownerID = ownerID;
    this.keyHash = keyHash;
    this.entry = entry;
  };

  ValueNode.prototype.get = function get (shift, keyHash, key, notSetValue) {
    return is(key, this.entry[0]) ? this.entry[1] : notSetValue;
  };

  ValueNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
    var removed = value === NOT_SET;
    var keyMatch = is(key, this.entry[0]);
    if (keyMatch ? value === this.entry[1] : removed) {
      return this;
    }

    SetRef(didAlter);

    if (removed) {
      SetRef(didChangeSize);
      return; // undefined
    }

    if (keyMatch) {
      if (ownerID && ownerID === this.ownerID) {
        this.entry[1] = value;
        return this;
      }
      return new ValueNode(ownerID, this.keyHash, [key, value]);
    }

    SetRef(didChangeSize);
    return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);
  };

  // #pragma Iterators

  ArrayMapNode.prototype.iterate = HashCollisionNode.prototype.iterate =
    function (fn, reverse) {
      var entries = this.entries;
      for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {
        if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {
          return false;
        }
      }
    };

  BitmapIndexedNode.prototype.iterate = HashArrayMapNode.prototype.iterate =
    function (fn, reverse) {
      var nodes = this.nodes;
      for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {
        var node = nodes[reverse ? maxIndex - ii : ii];
        if (node && node.iterate(fn, reverse) === false) {
          return false;
        }
      }
    };

  // eslint-disable-next-line no-unused-vars
  ValueNode.prototype.iterate = function (fn, reverse) {
    return fn(this.entry);
  };

  var MapIterator = /*@__PURE__*/(function (Iterator) {
    function MapIterator(map, type, reverse) {
      this._type = type;
      this._reverse = reverse;
      this._stack = map._root && mapIteratorFrame(map._root);
    }

    if ( Iterator ) MapIterator.__proto__ = Iterator;
    MapIterator.prototype = Object.create( Iterator && Iterator.prototype );
    MapIterator.prototype.constructor = MapIterator;

    MapIterator.prototype.next = function next () {
      var type = this._type;
      var stack = this._stack;
      while (stack) {
        var node = stack.node;
        var index = stack.index++;
        var maxIndex = (void 0);
        if (node.entry) {
          if (index === 0) {
            return mapIteratorValue(type, node.entry);
          }
        } else if (node.entries) {
          maxIndex = node.entries.length - 1;
          if (index <= maxIndex) {
            return mapIteratorValue(
              type,
              node.entries[this._reverse ? maxIndex - index : index]
            );
          }
        } else {
          maxIndex = node.nodes.length - 1;
          if (index <= maxIndex) {
            var subNode = node.nodes[this._reverse ? maxIndex - index : index];
            if (subNode) {
              if (subNode.entry) {
                return mapIteratorValue(type, subNode.entry);
              }
              stack = this._stack = mapIteratorFrame(subNode, stack);
            }
            continue;
          }
        }
        stack = this._stack = this._stack.__prev;
      }
      return iteratorDone();
    };

    return MapIterator;
  }(Iterator));

  function mapIteratorValue(type, entry) {
    return iteratorValue(type, entry[0], entry[1]);
  }

  function mapIteratorFrame(node, prev) {
    return {
      node: node,
      index: 0,
      __prev: prev,
    };
  }

  function makeMap(size, root, ownerID, hash) {
    var map = Object.create(MapPrototype);
    map.size = size;
    map._root = root;
    map.__ownerID = ownerID;
    map.__hash = hash;
    map.__altered = false;
    return map;
  }

  var EMPTY_MAP;
  function emptyMap() {
    return EMPTY_MAP || (EMPTY_MAP = makeMap(0));
  }

  function updateMap(map, k, v) {
    var newRoot;
    var newSize;
    if (!map._root) {
      if (v === NOT_SET) {
        return map;
      }
      newSize = 1;
      newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]);
    } else {
      var didChangeSize = MakeRef();
      var didAlter = MakeRef();
      newRoot = updateNode(
        map._root,
        map.__ownerID,
        0,
        undefined,
        k,
        v,
        didChangeSize,
        didAlter
      );
      if (!didAlter.value) {
        return map;
      }
      newSize = map.size + (didChangeSize.value ? (v === NOT_SET ? -1 : 1) : 0);
    }
    if (map.__ownerID) {
      map.size = newSize;
      map._root = newRoot;
      map.__hash = undefined;
      map.__altered = true;
      return map;
    }
    return newRoot ? makeMap(newSize, newRoot) : emptyMap();
  }

  function updateNode(
    node,
    ownerID,
    shift,
    keyHash,
    key,
    value,
    didChangeSize,
    didAlter
  ) {
    if (!node) {
      if (value === NOT_SET) {
        return node;
      }
      SetRef(didAlter);
      SetRef(didChangeSize);
      return new ValueNode(ownerID, keyHash, [key, value]);
    }
    return node.update(
      ownerID,
      shift,
      keyHash,
      key,
      value,
      didChangeSize,
      didAlter
    );
  }

  function isLeafNode(node) {
    return (
      node.constructor === ValueNode || node.constructor === HashCollisionNode
    );
  }

  function mergeIntoNode(node, ownerID, shift, keyHash, entry) {
    if (node.keyHash === keyHash) {
      return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);
    }

    var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;
    var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;

    var newNode;
    var nodes =
      idx1 === idx2
        ? [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)]
        : ((newNode = new ValueNode(ownerID, keyHash, entry)),
          idx1 < idx2 ? [node, newNode] : [newNode, node]);

    return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes);
  }

  function createNodes(ownerID, entries, key, value) {
    if (!ownerID) {
      ownerID = new OwnerID();
    }
    var node = new ValueNode(ownerID, hash(key), [key, value]);
    for (var ii = 0; ii < entries.length; ii++) {
      var entry = entries[ii];
      node = node.update(ownerID, 0, undefined, entry[0], entry[1]);
    }
    return node;
  }

  function packNodes(ownerID, nodes, count, excluding) {
    var bitmap = 0;
    var packedII = 0;
    var packedNodes = new Array(count);
    for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) {
      var node = nodes[ii];
      if (node !== undefined && ii !== excluding) {
        bitmap |= bit;
        packedNodes[packedII++] = node;
      }
    }
    return new BitmapIndexedNode(ownerID, bitmap, packedNodes);
  }

  function expandNodes(ownerID, nodes, bitmap, including, node) {
    var count = 0;
    var expandedNodes = new Array(SIZE);
    for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {
      expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined;
    }
    expandedNodes[including] = node;
    return new HashArrayMapNode(ownerID, count + 1, expandedNodes);
  }

  function popCount(x) {
    x -= (x >> 1) & 0x55555555;
    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
    x = (x + (x >> 4)) & 0x0f0f0f0f;
    x += x >> 8;
    x += x >> 16;
    return x & 0x7f;
  }

  function setAt(array, idx, val, canEdit) {
    var newArray = canEdit ? array : arrCopy(array);
    newArray[idx] = val;
    return newArray;
  }

  function spliceIn(array, idx, val, canEdit) {
    var newLen = array.length + 1;
    if (canEdit && idx + 1 === newLen) {
      array[idx] = val;
      return array;
    }
    var newArray = new Array(newLen);
    var after = 0;
    for (var ii = 0; ii < newLen; ii++) {
      if (ii === idx) {
        newArray[ii] = val;
        after = -1;
      } else {
        newArray[ii] = array[ii + after];
      }
    }
    return newArray;
  }

  function spliceOut(array, idx, canEdit) {
    var newLen = array.length - 1;
    if (canEdit && idx === newLen) {
      array.pop();
      return array;
    }
    var newArray = new Array(newLen);
    var after = 0;
    for (var ii = 0; ii < newLen; ii++) {
      if (ii === idx) {
        after = 1;
      }
      newArray[ii] = array[ii + after];
    }
    return newArray;
  }

  var MAX_ARRAY_MAP_SIZE = SIZE / 4;
  var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;
  var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;

  var IS_LIST_SYMBOL = '@@__IMMUTABLE_LIST__@@';

  function isList(maybeList) {
    return Boolean(maybeList && maybeList[IS_LIST_SYMBOL]);
  }

  var List = /*@__PURE__*/(function (IndexedCollection) {
    function List(value) {
      var empty = emptyList();
      if (value === undefined || value === null) {
        return empty;
      }
      if (isList(value)) {
        return value;
      }
      var iter = IndexedCollection(value);
      var size = iter.size;
      if (size === 0) {
        return empty;
      }
      assertNotInfinite(size);
      if (size > 0 && size < SIZE) {
        return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));
      }
      return empty.withMutations(function (list) {
        list.setSize(size);
        iter.forEach(function (v, i) { return list.set(i, v); });
      });
    }

    if ( IndexedCollection ) List.__proto__ = IndexedCollection;
    List.prototype = Object.create( IndexedCollection && IndexedCollection.prototype );
    List.prototype.constructor = List;

    List.of = function of (/*...values*/) {
      return this(arguments);
    };

    List.prototype.toString = function toString () {
      return this.__toString('List [', ']');
    };

    // @pragma Access

    List.prototype.get = function get (index, notSetValue) {
      index = wrapIndex(this, index);
      if (index >= 0 && index < this.size) {
        index += this._origin;
        var node = listNodeFor(this, index);
        return node && node.array[index & MASK];
      }
      return notSetValue;
    };

    // @pragma Modification

    List.prototype.set = function set (index, value) {
      return updateList(this, index, value);
    };

    List.prototype.remove = function remove (index) {
      return !this.has(index)
        ? this
        : index === 0
        ? this.shift()
        : index === this.size - 1
        ? this.pop()
        : this.splice(index, 1);
    };

    List.prototype.insert = function insert (index, value) {
      return this.splice(index, 0, value);
    };

    List.prototype.clear = function clear () {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = this._origin = this._capacity = 0;
        this._level = SHIFT;
        this._root = this._tail = this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return emptyList();
    };

    List.prototype.push = function push (/*...values*/) {
      var values = arguments;
      var oldSize = this.size;
      return this.withMutations(function (list) {
        setListBounds(list, 0, oldSize + values.length);
        for (var ii = 0; ii < values.length; ii++) {
          list.set(oldSize + ii, values[ii]);
        }
      });
    };

    List.prototype.pop = function pop () {
      return setListBounds(this, 0, -1);
    };

    List.prototype.unshift = function unshift (/*...values*/) {
      var values = arguments;
      return this.withMutations(function (list) {
        setListBounds(list, -values.length);
        for (var ii = 0; ii < values.length; ii++) {
          list.set(ii, values[ii]);
        }
      });
    };

    List.prototype.shift = function shift () {
      return setListBounds(this, 1);
    };

    // @pragma Composition

    List.prototype.concat = function concat (/*...collections*/) {
      var arguments$1 = arguments;

      var seqs = [];
      for (var i = 0; i < arguments.length; i++) {
        var argument = arguments$1[i];
        var seq = IndexedCollection(
          typeof argument !== 'string' && hasIterator(argument)
            ? argument
            : [argument]
        );
        if (seq.size !== 0) {
          seqs.push(seq);
        }
      }
      if (seqs.length === 0) {
        return this;
      }
      if (this.size === 0 && !this.__ownerID && seqs.length === 1) {
        return this.constructor(seqs[0]);
      }
      return this.withMutations(function (list) {
        seqs.forEach(function (seq) { return seq.forEach(function (value) { return list.push(value); }); });
      });
    };

    List.prototype.setSize = function setSize (size) {
      return setListBounds(this, 0, size);
    };

    List.prototype.map = function map (mapper, context) {
      var this$1$1 = this;

      return this.withMutations(function (list) {
        for (var i = 0; i < this$1$1.size; i++) {
          list.set(i, mapper.call(context, list.get(i), i, this$1$1));
        }
      });
    };

    // @pragma Iteration

    List.prototype.slice = function slice (begin, end) {
      var size = this.size;
      if (wholeSlice(begin, end, size)) {
        return this;
      }
      return setListBounds(
        this,
        resolveBegin(begin, size),
        resolveEnd(end, size)
      );
    };

    List.prototype.__iterator = function __iterator (type, reverse) {
      var index = reverse ? this.size : 0;
      var values = iterateList(this, reverse);
      return new Iterator(function () {
        var value = values();
        return value === DONE
          ? iteratorDone()
          : iteratorValue(type, reverse ? --index : index++, value);
      });
    };

    List.prototype.__iterate = function __iterate (fn, reverse) {
      var index = reverse ? this.size : 0;
      var values = iterateList(this, reverse);
      var value;
      while ((value = values()) !== DONE) {
        if (fn(value, reverse ? --index : index++, this) === false) {
          break;
        }
      }
      return index;
    };

    List.prototype.__ensureOwner = function __ensureOwner (ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      if (!ownerID) {
        if (this.size === 0) {
          return emptyList();
        }
        this.__ownerID = ownerID;
        this.__altered = false;
        return this;
      }
      return makeList(
        this._origin,
        this._capacity,
        this._level,
        this._root,
        this._tail,
        ownerID,
        this.__hash
      );
    };

    return List;
  }(IndexedCollection));

  List.isList = isList;

  var ListPrototype = List.prototype;
  ListPrototype[IS_LIST_SYMBOL] = true;
  ListPrototype[DELETE] = ListPrototype.remove;
  ListPrototype.merge = ListPrototype.concat;
  ListPrototype.setIn = setIn;
  ListPrototype.deleteIn = ListPrototype.removeIn = deleteIn;
  ListPrototype.update = update;
  ListPrototype.updateIn = updateIn;
  ListPrototype.mergeIn = mergeIn;
  ListPrototype.mergeDeepIn = mergeDeepIn;
  ListPrototype.withMutations = withMutations;
  ListPrototype.wasAltered = wasAltered;
  ListPrototype.asImmutable = asImmutable;
  ListPrototype['@@transducer/init'] = ListPrototype.asMutable = asMutable;
  ListPrototype['@@transducer/step'] = function (result, arr) {
    return result.push(arr);
  };
  ListPrototype['@@transducer/result'] = function (obj) {
    return obj.asImmutable();
  };

  var VNode = function VNode(array, ownerID) {
    this.array = array;
    this.ownerID = ownerID;
  };

  // TODO: seems like these methods are very similar

  VNode.prototype.removeBefore = function removeBefore (ownerID, level, index) {
    if (index === level ? 1 << level : this.array.length === 0) {
      return this;
    }
    var originIndex = (index >>> level) & MASK;
    if (originIndex >= this.array.length) {
      return new VNode([], ownerID);
    }
    var removingFirst = originIndex === 0;
    var newChild;
    if (level > 0) {
      var oldChild = this.array[originIndex];
      newChild =
        oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);
      if (newChild === oldChild && removingFirst) {
        return this;
      }
    }
    if (removingFirst && !newChild) {
      return this;
    }
    var editable = editableVNode(this, ownerID);
    if (!removingFirst) {
      for (var ii = 0; ii < originIndex; ii++) {
        editable.array[ii] = undefined;
      }
    }
    if (newChild) {
      editable.array[originIndex] = newChild;
    }
    return editable;
  };

  VNode.prototype.removeAfter = function removeAfter (ownerID, level, index) {
    if (index === (level ? 1 << level : 0) || this.array.length === 0) {
      return this;
    }
    var sizeIndex = ((index - 1) >>> level) & MASK;
    if (sizeIndex >= this.array.length) {
      return this;
    }

    var newChild;
    if (level > 0) {
      var oldChild = this.array[sizeIndex];
      newChild =
        oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);
      if (newChild === oldChild && sizeIndex === this.array.length - 1) {
        return this;
      }
    }

    var editable = editableVNode(this, ownerID);
    editable.array.splice(sizeIndex + 1);
    if (newChild) {
      editable.array[sizeIndex] = newChild;
    }
    return editable;
  };

  var DONE = {};

  function iterateList(list, reverse) {
    var left = list._origin;
    var right = list._capacity;
    var tailPos = getTailOffset(right);
    var tail = list._tail;

    return iterateNodeOrLeaf(list._root, list._level, 0);

    function iterateNodeOrLeaf(node, level, offset) {
      return level === 0
        ? iterateLeaf(node, offset)
        : iterateNode(node, level, offset);
    }

    function iterateLeaf(node, offset) {
      var array = offset === tailPos ? tail && tail.array : node && node.array;
      var from = offset > left ? 0 : left - offset;
      var to = right - offset;
      if (to > SIZE) {
        to = SIZE;
      }
      return function () {
        if (from === to) {
          return DONE;
        }
        var idx = reverse ? --to : from++;
        return array && array[idx];
      };
    }

    function iterateNode(node, level, offset) {
      var values;
      var array = node && node.array;
      var from = offset > left ? 0 : (left - offset) >> level;
      var to = ((right - offset) >> level) + 1;
      if (to > SIZE) {
        to = SIZE;
      }
      return function () {
        while (true) {
          if (values) {
            var value = values();
            if (value !== DONE) {
              return value;
            }
            values = null;
          }
          if (from === to) {
            return DONE;
          }
          var idx = reverse ? --to : from++;
          values = iterateNodeOrLeaf(
            array && array[idx],
            level - SHIFT,
            offset + (idx << level)
          );
        }
      };
    }
  }

  function makeList(origin, capacity, level, root, tail, ownerID, hash) {
    var list = Object.create(ListPrototype);
    list.size = capacity - origin;
    list._origin = origin;
    list._capacity = capacity;
    list._level = level;
    list._root = root;
    list._tail = tail;
    list.__ownerID = ownerID;
    list.__hash = hash;
    list.__altered = false;
    return list;
  }

  var EMPTY_LIST;
  function emptyList() {
    return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT));
  }

  function updateList(list, index, value) {
    index = wrapIndex(list, index);

    if (index !== index) {
      return list;
    }

    if (index >= list.size || index < 0) {
      return list.withMutations(function (list) {
        index < 0
          ? setListBounds(list, index).set(0, value)
          : setListBounds(list, 0, index + 1).set(index, value);
      });
    }

    index += list._origin;

    var newTail = list._tail;
    var newRoot = list._root;
    var didAlter = MakeRef();
    if (index >= getTailOffset(list._capacity)) {
      newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter);
    } else {
      newRoot = updateVNode(
        newRoot,
        list.__ownerID,
        list._level,
        index,
        value,
        didAlter
      );
    }

    if (!didAlter.value) {
      return list;
    }

    if (list.__ownerID) {
      list._root = newRoot;
      list._tail = newTail;
      list.__hash = undefined;
      list.__altered = true;
      return list;
    }
    return makeList(list._origin, list._capacity, list._level, newRoot, newTail);
  }

  function updateVNode(node, ownerID, level, index, value, didAlter) {
    var idx = (index >>> level) & MASK;
    var nodeHas = node && idx < node.array.length;
    if (!nodeHas && value === undefined) {
      return node;
    }

    var newNode;

    if (level > 0) {
      var lowerNode = node && node.array[idx];
      var newLowerNode = updateVNode(
        lowerNode,
        ownerID,
        level - SHIFT,
        index,
        value,
        didAlter
      );
      if (newLowerNode === lowerNode) {
        return node;
      }
      newNode = editableVNode(node, ownerID);
      newNode.array[idx] = newLowerNode;
      return newNode;
    }

    if (nodeHas && node.array[idx] === value) {
      return node;
    }

    if (didAlter) {
      SetRef(didAlter);
    }

    newNode = editableVNode(node, ownerID);
    if (value === undefined && idx === newNode.array.length - 1) {
      newNode.array.pop();
    } else {
      newNode.array[idx] = value;
    }
    return newNode;
  }

  function editableVNode(node, ownerID) {
    if (ownerID && node && ownerID === node.ownerID) {
      return node;
    }
    return new VNode(node ? node.array.slice() : [], ownerID);
  }

  function listNodeFor(list, rawIndex) {
    if (rawIndex >= getTailOffset(list._capacity)) {
      return list._tail;
    }
    if (rawIndex < 1 << (list._level + SHIFT)) {
      var node = list._root;
      var level = list._level;
      while (node && level > 0) {
        node = node.array[(rawIndex >>> level) & MASK];
        level -= SHIFT;
      }
      return node;
    }
  }

  function setListBounds(list, begin, end) {
    // Sanitize begin & end using this shorthand for ToInt32(argument)
    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
    if (begin !== undefined) {
      begin |= 0;
    }
    if (end !== undefined) {
      end |= 0;
    }
    var owner = list.__ownerID || new OwnerID();
    var oldOrigin = list._origin;
    var oldCapacity = list._capacity;
    var newOrigin = oldOrigin + begin;
    var newCapacity =
      end === undefined
        ? oldCapacity
        : end < 0
        ? oldCapacity + end
        : oldOrigin + end;
    if (newOrigin === oldOrigin && newCapacity === oldCapacity) {
      return list;
    }

    // If it's going to end after it starts, it's empty.
    if (newOrigin >= newCapacity) {
      return list.clear();
    }

    var newLevel = list._level;
    var newRoot = list._root;

    // New origin might need creating a higher root.
    var offsetShift = 0;
    while (newOrigin + offsetShift < 0) {
      newRoot = new VNode(
        newRoot && newRoot.array.length ? [undefined, newRoot] : [],
        owner
      );
      newLevel += SHIFT;
      offsetShift += 1 << newLevel;
    }
    if (offsetShift) {
      newOrigin += offsetShift;
      oldOrigin += offsetShift;
      newCapacity += offsetShift;
      oldCapacity += offsetShift;
    }

    var oldTailOffset = getTailOffset(oldCapacity);
    var newTailOffset = getTailOffset(newCapacity);

    // New size might need creating a higher root.
    while (newTailOffset >= 1 << (newLevel + SHIFT)) {
      newRoot = new VNode(
        newRoot && newRoot.array.length ? [newRoot] : [],
        owner
      );
      newLevel += SHIFT;
    }

    // Locate or create the new tail.
    var oldTail = list._tail;
    var newTail =
      newTailOffset < oldTailOffset
        ? listNodeFor(list, newCapacity - 1)
        : newTailOffset > oldTailOffset
        ? new VNode([], owner)
        : oldTail;

    // Merge Tail into tree.
    if (
      oldTail &&
      newTailOffset > oldTailOffset &&
      newOrigin < oldCapacity &&
      oldTail.array.length
    ) {
      newRoot = editableVNode(newRoot, owner);
      var node = newRoot;
      for (var level = newLevel; level > SHIFT; level -= SHIFT) {
        var idx = (oldTailOffset >>> level) & MASK;
        node = node.array[idx] = editableVNode(node.array[idx], owner);
      }
      node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail;
    }

    // If the size has been reduced, there's a chance the tail needs to be trimmed.
    if (newCapacity < oldCapacity) {
      newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);
    }

    // If the new origin is within the tail, then we do not need a root.
    if (newOrigin >= newTailOffset) {
      newOrigin -= newTailOffset;
      newCapacity -= newTailOffset;
      newLevel = SHIFT;
      newRoot = null;
      newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);

      // Otherwise, if the root has been trimmed, garbage collect.
    } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {
      offsetShift = 0;

      // Identify the new top root node of the subtree of the old root.
      while (newRoot) {
        var beginIndex = (newOrigin >>> newLevel) & MASK;
        if ((beginIndex !== newTailOffset >>> newLevel) & MASK) {
          break;
        }
        if (beginIndex) {
          offsetShift += (1 << newLevel) * beginIndex;
        }
        newLevel -= SHIFT;
        newRoot = newRoot.array[beginIndex];
      }

      // Trim the new sides of the new root.
      if (newRoot && newOrigin > oldOrigin) {
        newRoot = newRoot.removeBefore(owner, newLevel, newOrigin - offsetShift);
      }
      if (newRoot && newTailOffset < oldTailOffset) {
        newRoot = newRoot.removeAfter(
          owner,
          newLevel,
          newTailOffset - offsetShift
        );
      }
      if (offsetShift) {
        newOrigin -= offsetShift;
        newCapacity -= offsetShift;
      }
    }

    if (list.__ownerID) {
      list.size = newCapacity - newOrigin;
      list._origin = newOrigin;
      list._capacity = newCapacity;
      list._level = newLevel;
      list._root = newRoot;
      list._tail = newTail;
      list.__hash = undefined;
      list.__altered = true;
      return list;
    }
    return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);
  }

  function getTailOffset(size) {
    return size < SIZE ? 0 : ((size - 1) >>> SHIFT) << SHIFT;
  }

  var OrderedMap = /*@__PURE__*/(function (Map) {
    function OrderedMap(value) {
      return value === undefined || value === null
        ? emptyOrderedMap()
        : isOrderedMap(value)
        ? value
        : emptyOrderedMap().withMutations(function (map) {
            var iter = KeyedCollection(value);
            assertNotInfinite(iter.size);
            iter.forEach(function (v, k) { return map.set(k, v); });
          });
    }

    if ( Map ) OrderedMap.__proto__ = Map;
    OrderedMap.prototype = Object.create( Map && Map.prototype );
    OrderedMap.prototype.constructor = OrderedMap;

    OrderedMap.of = function of (/*...values*/) {
      return this(arguments);
    };

    OrderedMap.prototype.toString = function toString () {
      return this.__toString('OrderedMap {', '}');
    };

    // @pragma Access

    OrderedMap.prototype.get = function get (k, notSetValue) {
      var index = this._map.get(k);
      return index !== undefined ? this._list.get(index)[1] : notSetValue;
    };

    // @pragma Modification

    OrderedMap.prototype.clear = function clear () {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = 0;
        this._map.clear();
        this._list.clear();
        this.__altered = true;
        return this;
      }
      return emptyOrderedMap();
    };

    OrderedMap.prototype.set = function set (k, v) {
      return updateOrderedMap(this, k, v);
    };

    OrderedMap.prototype.remove = function remove (k) {
      return updateOrderedMap(this, k, NOT_SET);
    };

    OrderedMap.prototype.__iterate = function __iterate (fn, reverse) {
      var this$1$1 = this;

      return this._list.__iterate(
        function (entry) { return entry && fn(entry[1], entry[0], this$1$1); },
        reverse
      );
    };

    OrderedMap.prototype.__iterator = function __iterator (type, reverse) {
      return this._list.fromEntrySeq().__iterator(type, reverse);
    };

    OrderedMap.prototype.__ensureOwner = function __ensureOwner (ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      var newMap = this._map.__ensureOwner(ownerID);
      var newList = this._list.__ensureOwner(ownerID);
      if (!ownerID) {
        if (this.size === 0) {
          return emptyOrderedMap();
        }
        this.__ownerID = ownerID;
        this.__altered = false;
        this._map = newMap;
        this._list = newList;
        return this;
      }
      return makeOrderedMap(newMap, newList, ownerID, this.__hash);
    };

    return OrderedMap;
  }(Map));

  OrderedMap.isOrderedMap = isOrderedMap;

  OrderedMap.prototype[IS_ORDERED_SYMBOL] = true;
  OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;

  function makeOrderedMap(map, list, ownerID, hash) {
    var omap = Object.create(OrderedMap.prototype);
    omap.size = map ? map.size : 0;
    omap._map = map;
    omap._list = list;
    omap.__ownerID = ownerID;
    omap.__hash = hash;
    omap.__altered = false;
    return omap;
  }

  var EMPTY_ORDERED_MAP;
  function emptyOrderedMap() {
    return (
      EMPTY_ORDERED_MAP ||
      (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()))
    );
  }

  function updateOrderedMap(omap, k, v) {
    var map = omap._map;
    var list = omap._list;
    var i = map.get(k);
    var has = i !== undefined;
    var newMap;
    var newList;
    if (v === NOT_SET) {
      // removed
      if (!has) {
        return omap;
      }
      if (list.size >= SIZE && list.size >= map.size * 2) {
        newList = list.filter(function (entry, idx) { return entry !== undefined && i !== idx; });
        newMap = newList
          .toKeyedSeq()
          .map(function (entry) { return entry[0]; })
          .flip()
          .toMap();
        if (omap.__ownerID) {
          newMap.__ownerID = newList.__ownerID = omap.__ownerID;
        }
      } else {
        newMap = map.remove(k);
        newList = i === list.size - 1 ? list.pop() : list.set(i, undefined);
      }
    } else if (has) {
      if (v === list.get(i)[1]) {
        return omap;
      }
      newMap = map;
      newList = list.set(i, [k, v]);
    } else {
      newMap = map.set(k, list.size);
      newList = list.set(list.size, [k, v]);
    }
    if (omap.__ownerID) {
      omap.size = newMap.size;
      omap._map = newMap;
      omap._list = newList;
      omap.__hash = undefined;
      omap.__altered = true;
      return omap;
    }
    return makeOrderedMap(newMap, newList);
  }

  var IS_STACK_SYMBOL = '@@__IMMUTABLE_STACK__@@';

  function isStack(maybeStack) {
    return Boolean(maybeStack && maybeStack[IS_STACK_SYMBOL]);
  }

  var Stack = /*@__PURE__*/(function (IndexedCollection) {
    function Stack(value) {
      return value === undefined || value === null
        ? emptyStack()
        : isStack(value)
        ? value
        : emptyStack().pushAll(value);
    }

    if ( IndexedCollection ) Stack.__proto__ = IndexedCollection;
    Stack.prototype = Object.create( IndexedCollection && IndexedCollection.prototype );
    Stack.prototype.constructor = Stack;

    Stack.of = function of (/*...values*/) {
      return this(arguments);
    };

    Stack.prototype.toString = function toString () {
      return this.__toString('Stack [', ']');
    };

    // @pragma Access

    Stack.prototype.get = function get (index, notSetValue) {
      var head = this._head;
      index = wrapIndex(this, index);
      while (head && index--) {
        head = head.next;
      }
      return head ? head.value : notSetValue;
    };

    Stack.prototype.peek = function peek () {
      return this._head && this._head.value;
    };

    // @pragma Modification

    Stack.prototype.push = function push (/*...values*/) {
      var arguments$1 = arguments;

      if (arguments.length === 0) {
        return this;
      }
      var newSize = this.size + arguments.length;
      var head = this._head;
      for (var ii = arguments.length - 1; ii >= 0; ii--) {
        head = {
          value: arguments$1[ii],
          next: head,
        };
      }
      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return makeStack(newSize, head);
    };

    Stack.prototype.pushAll = function pushAll (iter) {
      iter = IndexedCollection(iter);
      if (iter.size === 0) {
        return this;
      }
      if (this.size === 0 && isStack(iter)) {
        return iter;
      }
      assertNotInfinite(iter.size);
      var newSize = this.size;
      var head = this._head;
      iter.__iterate(function (value) {
        newSize++;
        head = {
          value: value,
          next: head,
        };
      }, /* reverse */ true);
      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return makeStack(newSize, head);
    };

    Stack.prototype.pop = function pop () {
      return this.slice(1);
    };

    Stack.prototype.clear = function clear () {
      if (this.size === 0) {
        return this;
      }
      if (this.__ownerID) {
        this.size = 0;
        this._head = undefined;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return emptyStack();
    };

    Stack.prototype.slice = function slice (begin, end) {
      if (wholeSlice(begin, end, this.size)) {
        return this;
      }
      var resolvedBegin = resolveBegin(begin, this.size);
      var resolvedEnd = resolveEnd(end, this.size);
      if (resolvedEnd !== this.size) {
        // super.slice(begin, end);
        return IndexedCollection.prototype.slice.call(this, begin, end);
      }
      var newSize = this.size - resolvedBegin;
      var head = this._head;
      while (resolvedBegin--) {
        head = head.next;
      }
      if (this.__ownerID) {
        this.size = newSize;
        this._head = head;
        this.__hash = undefined;
        this.__altered = true;
        return this;
      }
      return makeStack(newSize, head);
    };

    // @pragma Mutability

    Stack.prototype.__ensureOwner = function __ensureOwner (ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      if (!ownerID) {
        if (this.size === 0) {
          return emptyStack();
        }
        this.__ownerID = ownerID;
        this.__altered = false;
        return this;
      }
      return makeStack(this.size, this._head, ownerID, this.__hash);
    };

    // @pragma Iteration

    Stack.prototype.__iterate = function __iterate (fn, reverse) {
      var this$1$1 = this;

      if (reverse) {
        return new ArraySeq(this.toArray()).__iterate(
          function (v, k) { return fn(v, k, this$1$1); },
          reverse
        );
      }
      var iterations = 0;
      var node = this._head;
      while (node) {
        if (fn(node.value, iterations++, this) === false) {
          break;
        }
        node = node.next;
      }
      return iterations;
    };

    Stack.prototype.__iterator = function __iterator (type, reverse) {
      if (reverse) {
        return new ArraySeq(this.toArray()).__iterator(type, reverse);
      }
      var iterations = 0;
      var node = this._head;
      return new Iterator(function () {
        if (node) {
          var value = node.value;
          node = node.next;
          return iteratorValue(type, iterations++, value);
        }
        return iteratorDone();
      });
    };

    return Stack;
  }(IndexedCollection));

  Stack.isStack = isStack;

  var StackPrototype = Stack.prototype;
  StackPrototype[IS_STACK_SYMBOL] = true;
  StackPrototype.shift = StackPrototype.pop;
  StackPrototype.unshift = StackPrototype.push;
  StackPrototype.unshiftAll = StackPrototype.pushAll;
  StackPrototype.withMutations = withMutations;
  StackPrototype.wasAltered = wasAltered;
  StackPrototype.asImmutable = asImmutable;
  StackPrototype['@@transducer/init'] = StackPrototype.asMutable = asMutable;
  StackPrototype['@@transducer/step'] = function (result, arr) {
    return result.unshift(arr);
  };
  StackPrototype['@@transducer/result'] = function (obj) {
    return obj.asImmutable();
  };

  function makeStack(size, head, ownerID, hash) {
    var map = Object.create(StackPrototype);
    map.size = size;
    map._head = head;
    map.__ownerID = ownerID;
    map.__hash = hash;
    map.__altered = false;
    return map;
  }

  var EMPTY_STACK;
  function emptyStack() {
    return EMPTY_STACK || (EMPTY_STACK = makeStack(0));
  }

  var IS_SET_SYMBOL = '@@__IMMUTABLE_SET__@@';

  function isSet(maybeSet) {
    return Boolean(maybeSet && maybeSet[IS_SET_SYMBOL]);
  }

  function isOrderedSet(maybeOrderedSet) {
    return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);
  }

  function deepEqual(a, b) {
    if (a === b) {
      return true;
    }

    if (
      !isCollection(b) ||
      (a.size !== undefined && b.size !== undefined && a.size !== b.size) ||
      (a.__hash !== undefined &&
        b.__hash !== undefined &&
        a.__hash !== b.__hash) ||
      isKeyed(a) !== isKeyed(b) ||
      isIndexed(a) !== isIndexed(b) ||
      isOrdered(a) !== isOrdered(b)
    ) {
      return false;
    }

    if (a.size === 0 && b.size === 0) {
      return true;
    }

    var notAssociative = !isAssociative(a);

    if (isOrdered(a)) {
      var entries = a.entries();
      return (
        b.every(function (v, k) {
          var entry = entries.next().value;
          return entry && is(entry[1], v) && (notAssociative || is(entry[0], k));
        }) && entries.next().done
      );
    }

    var flipped = false;

    if (a.size === undefined) {
      if (b.size === undefined) {
        if (typeof a.cacheResult === 'function') {
          a.cacheResult();
        }
      } else {
        flipped = true;
        var _ = a;
        a = b;
        b = _;
      }
    }

    var allEqual = true;
    var bSize = b.__iterate(function (v, k) {
      if (
        notAssociative
          ? !a.has(v)
          : flipped
          ? !is(v, a.get(k, NOT_SET))
          : !is(a.get(k, NOT_SET), v)
      ) {
        allEqual = false;
        return false;
      }
    });

    return allEqual && a.size === bSize;
  }

  function mixin(ctor, methods) {
    var keyCopier = function (key) {
      ctor.prototype[key] = methods[key];
    };
    Object.keys(methods).forEach(keyCopier);
    Object.getOwnPropertySymbols &&
      Object.getOwnPropertySymbols(methods).forEach(keyCopier);
    return ctor;
  }

  function toJS(value) {
    if (!value || typeof value !== 'object') {
      return value;
    }
    if (!isCollection(value)) {
      if (!isDataStructure(value)) {
        return value;
      }
      value = Seq(value);
    }
    if (isKeyed(value)) {
      var result$1 = {};
      value.__iterate(function (v, k) {
        result$1[k] = toJS(v);
      });
      return result$1;
    }
    var result = [];
    value.__iterate(function (v) {
      result.push(toJS(v));
    });
    return result;
  }

  var Set = /*@__PURE__*/(function (SetCollection) {
    function Set(value) {
      return value === undefined || value === null
        ? emptySet()
        : isSet(value) && !isOrdered(value)
        ? value
        : emptySet().withMutations(function (set) {
            var iter = SetCollection(value);
            assertNotInfinite(iter.size);
            iter.forEach(function (v) { return set.add(v); });
          });
    }

    if ( SetCollection ) Set.__proto__ = SetCollection;
    Set.prototype = Object.create( SetCollection && SetCollection.prototype );
    Set.prototype.constructor = Set;

    Set.of = function of (/*...values*/) {
      return this(arguments);
    };

    Set.fromKeys = function fromKeys (value) {
      return this(KeyedCollection(value).keySeq());
    };

    Set.intersect = function intersect (sets) {
      sets = Collection(sets).toArray();
      return sets.length
        ? SetPrototype.intersect.apply(Set(sets.pop()), sets)
        : emptySet();
    };

    Set.union = function union (sets) {
      sets = Collection(sets).toArray();
      return sets.length
        ? SetPrototype.union.apply(Set(sets.pop()), sets)
        : emptySet();
    };

    Set.prototype.toString = function toString () {
      return this.__toString('Set {', '}');
    };

    // @pragma Access

    Set.prototype.has = function has (value) {
      return this._map.has(value);
    };

    // @pragma Modification

    Set.prototype.add = function add (value) {
      return updateSet(this, this._map.set(value, value));
    };

    Set.prototype.remove = function remove (value) {
      return updateSet(this, this._map.remove(value));
    };

    Set.prototype.clear = function clear () {
      return updateSet(this, this._map.clear());
    };

    // @pragma Composition

    Set.prototype.map = function map (mapper, context) {
      var this$1$1 = this;

      // keep track if the set is altered by the map function
      var didChanges = false;

      var newMap = updateSet(
        this,
        this._map.mapEntries(function (ref) {
          var v = ref[1];

          var mapped = mapper.call(context, v, v, this$1$1);

          if (mapped !== v) {
            didChanges = true;
          }

          return [mapped, mapped];
        }, context)
      );

      return didChanges ? newMap : this;
    };

    Set.prototype.union = function union () {
      var iters = [], len = arguments.length;
      while ( len-- ) iters[ len ] = arguments[ len ];

      iters = iters.filter(function (x) { return x.size !== 0; });
      if (iters.length === 0) {
        return this;
      }
      if (this.size === 0 && !this.__ownerID && iters.length === 1) {
        return this.constructor(iters[0]);
      }
      return this.withMutations(function (set) {
        for (var ii = 0; ii < iters.length; ii++) {
          SetCollection(iters[ii]).forEach(function (value) { return set.add(value); });
        }
      });
    };

    Set.prototype.intersect = function intersect () {
      var iters = [], len = arguments.length;
      while ( len-- ) iters[ len ] = arguments[ len ];

      if (iters.length === 0) {
        return this;
      }
      iters = iters.map(function (iter) { return SetCollection(iter); });
      var toRemove = [];
      this.forEach(function (value) {
        if (!iters.every(function (iter) { return iter.includes(value); })) {
          toRemove.push(value);
        }
      });
      return this.withMutations(function (set) {
        toRemove.forEach(function (value) {
          set.remove(value);
        });
      });
    };

    Set.prototype.subtract = function subtract () {
      var iters = [], len = arguments.length;
      while ( len-- ) iters[ len ] = arguments[ len ];

      if (iters.length === 0) {
        return this;
      }
      iters = iters.map(function (iter) { return SetCollection(iter); });
      var toRemove = [];
      this.forEach(function (value) {
        if (iters.some(function (iter) { return iter.includes(value); })) {
          toRemove.push(value);
        }
      });
      return this.withMutations(function (set) {
        toRemove.forEach(function (value) {
          set.remove(value);
        });
      });
    };

    Set.prototype.sort = function sort (comparator) {
      // Late binding
      return OrderedSet(sortFactory(this, comparator));
    };

    Set.prototype.sortBy = function sortBy (mapper, comparator) {
      // Late binding
      return OrderedSet(sortFactory(this, comparator, mapper));
    };

    Set.prototype.wasAltered = function wasAltered () {
      return this._map.wasAltered();
    };

    Set.prototype.__iterate = function __iterate (fn, reverse) {
      var this$1$1 = this;

      return this._map.__iterate(function (k) { return fn(k, k, this$1$1); }, reverse);
    };

    Set.prototype.__iterator = function __iterator (type, reverse) {
      return this._map.__iterator(type, reverse);
    };

    Set.prototype.__ensureOwner = function __ensureOwner (ownerID) {
      if (ownerID === this.__ownerID) {
        return this;
      }
      var newMap = this._map.__ensureOwner(ownerID);
      if (!ownerID) {
        if (this.size === 0) {
          return this.__empty();
        }
        this.__ownerID = ownerID;
        this._map = newMap;
        return this;
      }
      return this.__make(newMap, ownerID);
    };

    return Set;
  }(SetCollection));

  Set.isSet = isSet;

  var SetPrototype = Set.prototype;
  SetPrototype[IS_SET_SYMBOL] = true;
  SetPrototype[DELETE] = SetPrototype.remove;
  SetPrototype.merge = SetPrototype.concat = SetPrototype.union;
  SetPrototype.withMutations = withMutations;
  SetPrototype.asImmutable = asImmutable;
  SetPrototype['@@transducer/init'] = SetPrototype.asMutable = asMutable;
  SetPrototype['@@transducer/step'] = function (result, arr) {
    return result.add(arr);
  };
  SetPrototype['@@transducer/result'] = function (obj) {
    return obj.asImmutable();
  };

  SetPrototype.__empty = emptySet;
  SetPrototype.__make = makeSet;

  function updateSet(set, newMap) {
    if (set.__ownerID) {
      set.size = newMap.size;
      set._map = newMap;
      return set;
    }
    return newMap === set._map
      ? set
      : newMap.size === 0
      ? set.__empty()
      : set.__make(newMap);
  }

  function makeSet(map, ownerID) {
    var set = Object.create(SetPrototype);
    set.size = map ? map.size : 0;
    set._map = map;
    set.__ownerID = ownerID;
    return set;
  }

  var EMPTY_SET;
  function emptySet() {
    return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));
  }

  /**
   * Returns a lazy seq of nums from start (inclusive) to end
   * (exclusive), by step, where start defaults to 0, step to 1, and end to
   * infinity. When start is equal to end, returns empty list.
   */
  var Range = /*@__PURE__*/(function (IndexedSeq) {
    function Range(start, end, step) {
      if (!(this instanceof Range)) {
        return new Range(start, end, step);
      }
      invariant(step !== 0, 'Cannot step a Range by 0');
      start = start || 0;
      if (end === undefined) {
        end = Infinity;
      }
      step = step === undefined ? 1 : Math.abs(step);
      if (end < start) {
        step = -step;
      }
      this._start = start;
      this._end = end;
      this._step = step;
      this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);
      if (this.size === 0) {
        if (EMPTY_RANGE) {
          return EMPTY_RANGE;
        }
        EMPTY_RANGE = this;
      }
    }

    if ( IndexedSeq ) Range.__proto__ = IndexedSeq;
    Range.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );
    Range.prototype.constructor = Range;

    Range.prototype.toString = function toString () {
      if (this.size === 0) {
        return 'Range []';
      }
      return (
        'Range [ ' +
        this._start +
        '...' +
        this._end +
        (this._step !== 1 ? ' by ' + this._step : '') +
        ' ]'
      );
    };

    Range.prototype.get = function get (index, notSetValue) {
      return this.has(index)
        ? this._start + wrapIndex(this, index) * this._step
        : notSetValue;
    };

    Range.prototype.includes = function includes (searchValue) {
      var possibleIndex = (searchValue - this._start) / this._step;
      return (
        possibleIndex >= 0 &&
        possibleIndex < this.size &&
        possibleIndex === Math.floor(possibleIndex)
      );
    };

    Range.prototype.slice = function slice (begin, end) {
      if (wholeSlice(begin, end, this.size)) {
        return this;
      }
      begin = resolveBegin(begin, this.size);
      end = resolveEnd(end, this.size);
      if (end <= begin) {
        return new Range(0, 0);
      }
      return new Range(
        this.get(begin, this._end),
        this.get(end, this._end),
        this._step
      );
    };

    Range.prototype.indexOf = function indexOf (searchValue) {
      var offsetValue = searchValue - this._start;
      if (offsetValue % this._step === 0) {
        var index = offsetValue / this._step;
        if (index >= 0 && index < this.size) {
          return index;
        }
      }
      return -1;
    };

    Range.prototype.lastIndexOf = function lastIndexOf (searchValue) {
      return this.indexOf(searchValue);
    };

    Range.prototype.__iterate = function __iterate (fn, reverse) {
      var size = this.size;
      var step = this._step;
      var value = reverse ? this._start + (size - 1) * step : this._start;
      var i = 0;
      while (i !== size) {
        if (fn(value, reverse ? size - ++i : i++, this) === false) {
          break;
        }
        value += reverse ? -step : step;
      }
      return i;
    };

    Range.prototype.__iterator = function __iterator (type, reverse) {
      var size = this.size;
      var step = this._step;
      var value = reverse ? this._start + (size - 1) * step : this._start;
      var i = 0;
      return new Iterator(function () {
        if (i === size) {
          return iteratorDone();
        }
        var v = value;
        value += reverse ? -step : step;
        return iteratorValue(type, reverse ? size - ++i : i++, v);
      });
    };

    Range.prototype.equals = function equals (other) {
      return other instanceof Range
        ? this._start === other._start &&
            this._end === other._end &&
            this._step === other._step
        : deepEqual(this, other);
    };

    return Range;
  }(IndexedSeq));

  var EMPTY_RANGE;

  function getIn$1(collection, searchKeyPath, notSetValue) {
    var keyPath = coerceKeyPath(searchKeyPath);
    var i = 0;
    while (i !== keyPath.length) {
      collection = get(collection, keyPath[i++], NOT_SET);
      if (collection === NOT_SET) {
        return notSetValue;
      }
    }
    return collection;
  }

  function getIn(searchKeyPath, notSetValue) {
    return getIn$1(this, searchKeyPath, notSetValue);
  }

  function hasIn$1(collection, keyPath) {
    return getIn$1(collection, keyPath, NOT_SET) !== NOT_SET;
  }

  function hasIn(searchKeyPath) {
    return hasIn$1(this, searchKeyPath);
  }

  function toObject() {
    assertNotInfinite(this.size);
    var object = {};
    this.__iterate(function (v, k) {
      object[k] = v;
    });
    return object;
  }

  // Note: all of these methods are deprecated.
  Collection.isIterable = isCollection;
  Collection.isKeyed = isKeyed;
  Collection.isIndexed = isIndexed;
  Collection.isAssociative = isAssociative;
  Collection.isOrdered = isOrdered;

  Collection.Iterator = Iterator;

  mixin(Collection, {
    // ### Conversion to other types

    toArray: function toArray() {
      assertNotInfinite(this.size);
      var array = new Array(this.size || 0);
      var useTuples = isKeyed(this);
      var i = 0;
      this.__iterate(function (v, k) {
        // Keyed collections produce an array of tuples.
        array[i++] = useTuples ? [k, v] : v;
      });
      return array;
    },

    toIndexedSeq: function toIndexedSeq() {
      return new ToIndexedSequence(this);
    },

    toJS: function toJS$1() {
      return toJS(this);
    },

    toKeyedSeq: function toKeyedSeq() {
      return new ToKeyedSequence(this, true);
    },

    toMap: function toMap() {
      // Use Late Binding here to solve the circular dependency.
      return Map(this.toKeyedSeq());
    },

    toObject: toObject,

    toOrderedMap: function toOrderedMap() {
      // Use Late Binding here to solve the circular dependency.
      return OrderedMap(this.toKeyedSeq());
    },

    toOrderedSet: function toOrderedSet() {
      // Use Late Binding here to solve the circular dependency.
      return OrderedSet(isKeyed(this) ? this.valueSeq() : this);
    },

    toSet: function toSet() {
      // Use Late Binding here to solve the circular dependency.
      return Set(isKeyed(this) ? this.valueSeq() : this);
    },

    toSetSeq: function toSetSeq() {
      return new ToSetSequence(this);
    },

    toSeq: function toSeq() {
      return isIndexed(this)
        ? this.toIndexedSeq()
        : isKeyed(this)
        ? this.toKeyedSeq()
        : this.toSetSeq();
    },

    toStack: function toStack() {
      // Use Late Binding here to solve the circular dependency.
      return Stack(isKeyed(this) ? this.valueSeq() : this);
    },

    toList: function toList() {
      // Use Late Binding here to solve the circular dependency.
      return List(isKeyed(this) ? this.valueSeq() : this);
    },

    // ### Common JavaScript methods and properties

    toString: function toString() {
      return '[Collection]';
    },

    __toString: function __toString(head, tail) {
      if (this.size === 0) {
        return head + tail;
      }
      return (
        head +
        ' ' +
        this.toSeq().map(this.__toStringMapper).join(', ') +
        ' ' +
        tail
      );
    },

    // ### ES6 Collection methods (ES6 Array and Map)

    concat: function concat() {
      var values = [], len = arguments.length;
      while ( len-- ) values[ len ] = arguments[ len ];

      return reify(this, concatFactory(this, values));
    },

    includes: function includes(searchValue) {
      return this.some(function (value) { return is(value, searchValue); });
    },

    entries: function entries() {
      return this.__iterator(ITERATE_ENTRIES);
    },

    every: function every(predicate, context) {
      assertNotInfinite(this.size);
      var returnValue = true;
      this.__iterate(function (v, k, c) {
        if (!predicate.call(context, v, k, c)) {
          returnValue = false;
          return false;
        }
      });
      return returnValue;
    },

    filter: function filter(predicate, context) {
      return reify(this, filterFactory(this, predicate, context, true));
    },

    find: function find(predicate, context, notSetValue) {
      var entry = this.findEntry(predicate, context);
      return entry ? entry[1] : notSetValue;
    },

    forEach: function forEach(sideEffect, context) {
      assertNotInfinite(this.size);
      return this.__iterate(context ? sideEffect.bind(context) : sideEffect);
    },

    join: function join(separator) {
      assertNotInfinite(this.size);
      separator = separator !== undefined ? '' + separator : ',';
      var joined = '';
      var isFirst = true;
      this.__iterate(function (v) {
        isFirst ? (isFirst = false) : (joined += separator);
        joined += v !== null && v !== undefined ? v.toString() : '';
      });
      return joined;
    },

    keys: function keys() {
      return this.__iterator(ITERATE_KEYS);
    },

    map: function map(mapper, context) {
      return reify(this, mapFactory(this, mapper, context));
    },

    reduce: function reduce$1(reducer, initialReduction, context) {
      return reduce(
        this,
        reducer,
        initialReduction,
        context,
        arguments.length < 2,
        false
      );
    },

    reduceRight: function reduceRight(reducer, initialReduction, context) {
      return reduce(
        this,
        reducer,
        initialReduction,
        context,
        arguments.length < 2,
        true
      );
    },

    reverse: function reverse() {
      return reify(this, reverseFactory(this, true));
    },

    slice: function slice(begin, end) {
      return reify(this, sliceFactory(this, begin, end, true));
    },

    some: function some(predicate, context) {
      return !this.every(not(predicate), context);
    },

    sort: function sort(comparator) {
      return reify(this, sortFactory(this, comparator));
    },

    values: function values() {
      return this.__iterator(ITERATE_VALUES);
    },

    // ### More sequential methods

    butLast: function butLast() {
      return this.slice(0, -1);
    },

    isEmpty: function isEmpty() {
      return this.size !== undefined ? this.size === 0 : !this.some(function () { return true; });
    },

    count: function count(predicate, context) {
      return ensureSize(
        predicate ? this.toSeq().filter(predicate, context) : this
      );
    },

    countBy: function countBy(grouper, context) {
      return countByFactory(this, grouper, context);
    },

    equals: function equals(other) {
      return deepEqual(this, other);
    },

    entrySeq: function entrySeq() {
      var collection = this;
      if (collection._cache) {
        // We cache as an entries array, so we can just return the cache!
        return new ArraySeq(collection._cache);
      }
      var entriesSequence = collection.toSeq().map(entryMapper).toIndexedSeq();
      entriesSequence.fromEntrySeq = function () { return collection.toSeq(); };
      return entriesSequence;
    },

    filterNot: function filterNot(predicate, context) {
      return this.filter(not(predicate), context);
    },

    findEntry: function findEntry(predicate, context, notSetValue) {
      var found = notSetValue;
      this.__iterate(function (v, k, c) {
        if (predicate.call(context, v, k, c)) {
          found = [k, v];
          return false;
        }
      });
      return found;
    },

    findKey: function findKey(predicate, context) {
      var entry = this.findEntry(predicate, context);
      return entry && entry[0];
    },

    findLast: function findLast(predicate, context, notSetValue) {
      return this.toKeyedSeq().reverse().find(predicate, context, notSetValue);
    },

    findLastEntry: function findLastEntry(predicate, context, notSetValue) {
      return this.toKeyedSeq()
        .reverse()
        .findEntry(predicate, context, notSetValue);
    },

    findLastKey: function findLastKey(predicate, context) {
      return this.toKeyedSeq().reverse().findKey(predicate, context);
    },

    first: function first(notSetValue) {
      return this.find(returnTrue, null, notSetValue);
    },

    flatMap: function flatMap(mapper, context) {
      return reify(this, flatMapFactory(this, mapper, context));
    },

    flatten: function flatten(depth) {
      return reify(this, flattenFactory(this, depth, true));
    },

    fromEntrySeq: function fromEntrySeq() {
      return new FromEntriesSequence(this);
    },

    get: function get(searchKey, notSetValue) {
      return this.find(function (_, key) { return is(key, searchKey); }, undefined, notSetValue);
    },

    getIn: getIn,

    groupBy: function groupBy(grouper, context) {
      return groupByFactory(this, grouper, context);
    },

    has: function has(searchKey) {
      return this.get(searchKey, NOT_SET) !== NOT_SET;
    },

    hasIn: hasIn,

    isSubset: function isSubset(iter) {
      iter = typeof iter.includes === 'function' ? iter : Collection(iter);
      return this.every(function (value) { return iter.includes(value); });
    },

    isSuperset: function isSuperset(iter) {
      iter = typeof iter.isSubset === 'function' ? iter : Collection(iter);
      return iter.isSubset(this);
    },

    keyOf: function keyOf(searchValue) {
      return this.findKey(function (value) { return is(value, searchValue); });
    },

    keySeq: function keySeq() {
      return this.toSeq().map(keyMapper).toIndexedSeq();
    },

    last: function last(notSetValue) {
      return this.toSeq().reverse().first(notSetValue);
    },

    lastKeyOf: function lastKeyOf(searchValue) {
      return this.toKeyedSeq().reverse().keyOf(searchValue);
    },

    max: function max(comparator) {
      return maxFactory(this, comparator);
    },

    maxBy: function maxBy(mapper, comparator) {
      return maxFactory(this, comparator, mapper);
    },

    min: function min(comparator) {
      return maxFactory(
        this,
        comparator ? neg(comparator) : defaultNegComparator
      );
    },

    minBy: function minBy(mapper, comparator) {
      return maxFactory(
        this,
        comparator ? neg(comparator) : defaultNegComparator,
        mapper
      );
    },

    rest: function rest() {
      return this.slice(1);
    },

    skip: function skip(amount) {
      return amount === 0 ? this : this.slice(Math.max(0, amount));
    },

    skipLast: function skipLast(amount) {
      return amount === 0 ? this : this.slice(0, -Math.max(0, amount));
    },

    skipWhile: function skipWhile(predicate, context) {
      return reify(this, skipWhileFactory(this, predicate, context, true));
    },

    skipUntil: function skipUntil(predicate, context) {
      return this.skipWhile(not(predicate), context);
    },

    sortBy: function sortBy(mapper, comparator) {
      return reify(this, sortFactory(this, comparator, mapper));
    },

    take: function take(amount) {
      return this.slice(0, Math.max(0, amount));
    },

    takeLast: function takeLast(amount) {
      return this.slice(-Math.max(0, amount));
    },

    takeWhile: function takeWhile(predicate, context) {
      return reify(this, takeWhileFactory(this, predicate, context));
    },

    takeUntil: function takeUntil(predicate, context) {
      return this.takeWhile(not(predicate), context);
    },

    update: function update(fn) {
      return fn(this);
    },

    valueSeq: function valueSeq() {
      return this.toIndexedSeq();
    },

    // ### Hashable Object

    hashCode: function hashCode() {
      return this.__hash || (this.__hash = hashCollection(this));
    },

    // ### Internal

    // abstract __iterate(fn, reverse)

    // abstract __iterator(type, reverse)
  });

  var CollectionPrototype = Collection.prototype;
  CollectionPrototype[IS_COLLECTION_SYMBOL] = true;
  CollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.values;
  CollectionPrototype.toJSON = CollectionPrototype.toArray;
  CollectionPrototype.__toStringMapper = quoteString;
  CollectionPrototype.inspect = CollectionPrototype.toSource = function () {
    return this.toString();
  };
  CollectionPrototype.chain = CollectionPrototype.flatMap;
  CollectionPrototype.contains = CollectionPrototype.includes;

  mixin(KeyedCollection, {
    // ### More sequential methods

    flip: function flip() {
      return reify(this, flipFactory(this));
    },

    mapEntries: function mapEntries(mapper, context) {
      var this$1$1 = this;

      var iterations = 0;
      return reify(
        this,
        this.toSeq()
          .map(function (v, k) { return mapper.call(context, [k, v], iterations++, this$1$1); })
          .fromEntrySeq()
      );
    },

    mapKeys: function mapKeys(mapper, context) {
      var this$1$1 = this;

      return reify(
        this,
        this.toSeq()
          .flip()
          .map(function (k, v) { return mapper.call(context, k, v, this$1$1); })
          .flip()
      );
    },
  });

  var KeyedCollectionPrototype = KeyedCollection.prototype;
  KeyedCollectionPrototype[IS_KEYED_SYMBOL] = true;
  KeyedCollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.entries;
  KeyedCollectionPrototype.toJSON = toObject;
  KeyedCollectionPrototype.__toStringMapper = function (v, k) { return quoteString(k) + ': ' + quoteString(v); };

  mixin(IndexedCollection, {
    // ### Conversion to other types

    toKeyedSeq: function toKeyedSeq() {
      return new ToKeyedSequence(this, false);
    },

    // ### ES6 Collection methods (ES6 Array and Map)

    filter: function filter(predicate, context) {
      return reify(this, filterFactory(this, predicate, context, false));
    },

    findIndex: function findIndex(predicate, context) {
      var entry = this.findEntry(predicate, context);
      return entry ? entry[0] : -1;
    },

    indexOf: function indexOf(searchValue) {
      var key = this.keyOf(searchValue);
      return key === undefined ? -1 : key;
    },

    lastIndexOf: function lastIndexOf(searchValue) {
      var key = this.lastKeyOf(searchValue);
      return key === undefined ? -1 : key;
    },

    reverse: function reverse() {
      return reify(this, reverseFactory(this, false));
    },

    slice: function slice(begin, end) {
      return reify(this, sliceFactory(this, begin, end, false));
    },

    splice: function splice(index, removeNum /*, ...values*/) {
      var numArgs = arguments.length;
      removeNum = Math.max(removeNum || 0, 0);
      if (numArgs === 0 || (numArgs === 2 && !removeNum)) {
        return this;
      }
      // If index is negative, it should resolve relative to the size of the
      // collection. However size may be expensive to compute if not cached, so
      // only call count() if the number is in fact negative.
      index = resolveBegin(index, index < 0 ? this.count() : this.size);
      var spliced = this.slice(0, index);
      return reify(
        this,
        numArgs === 1
          ? spliced
          : spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum))
      );
    },

    // ### More collection methods

    findLastIndex: function findLastIndex(predicate, context) {
      var entry = this.findLastEntry(predicate, context);
      return entry ? entry[0] : -1;
    },

    first: function first(notSetValue) {
      return this.get(0, notSetValue);
    },

    flatten: function flatten(depth) {
      return reify(this, flattenFactory(this, depth, false));
    },

    get: function get(index, notSetValue) {
      index = wrapIndex(this, index);
      return index < 0 ||
        this.size === Infinity ||
        (this.size !== undefined && index > this.size)
        ? notSetValue
        : this.find(function (_, key) { return key === index; }, undefined, notSetValue);
    },

    has: function has(index) {
      index = wrapIndex(this, index);
      return (
        index >= 0 &&
        (this.size !== undefined
          ? this.size === Infinity || index < this.size
          : this.indexOf(index) !== -1)
      );
    },

    interpose: function interpose(separator) {
      return reify(this, interposeFactory(this, separator));
    },

    interleave: function interleave(/*...collections*/) {
      var collections = [this].concat(arrCopy(arguments));
      var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, collections);
      var interleaved = zipped.flatten(true);
      if (zipped.size) {
        interleaved.size = zipped.size * collections.length;
      }
      return reify(this, interleaved);
    },

    keySeq: function keySeq() {
      return Range(0, this.size);
    },

    last: function last(notSetValue) {
      return this.get(-1, notSetValue);
    },

    skipWhile: function skipWhile(predicate, context) {
      return reify(this, skipWhileFactory(this, predicate, context, false));
    },

    zip: function zip(/*, ...collections */) {
      var collections = [this].concat(arrCopy(arguments));
      return reify(this, zipWithFactory(this, defaultZipper, collections));
    },

    zipAll: function zipAll(/*, ...collections */) {
      var collections = [this].concat(arrCopy(arguments));
      return reify(this, zipWithFactory(this, defaultZipper, collections, true));
    },

    zipWith: function zipWith(zipper /*, ...collections */) {
      var collections = arrCopy(arguments);
      collections[0] = this;
      return reify(this, zipWithFactory(this, zipper, collections));
    },
  });

  var IndexedCollectionPrototype = IndexedCollection.prototype;
  IndexedCollectionPrototype[IS_INDEXED_SYMBOL] = true;
  IndexedCollectionPrototype[IS_ORDERED_SYMBOL] = true;

  mixin(SetCollection, {
    // ### ES6 Collection methods (ES6 Array and Map)

    get: function get(value, notSetValue) {
      return this.has(value) ? value : notSetValue;
    },

    includes: function includes(value) {
      return this.has(value);
    },

    // ### More sequential methods

    keySeq: function keySeq() {
      return this.valueSeq();
    },
  });

  var SetCollectionPrototype = SetCollection.prototype;
  SetCollectionPrototype.has = CollectionPrototype.includes;
  SetCollectionPrototype.contains = SetCollectionPrototype.includes;
  SetCollectionPrototype.keys = SetCollectionPrototype.values;

  // Mixin subclasses

  mixin(KeyedSeq, KeyedCollectionPrototype);
  mixin(IndexedSeq, IndexedCollectionPrototype);
  mixin(SetSeq, SetCollectionPrototype);

  // #pragma Helper functions

  function reduce(collection, reducer, reduction, context, useFirst, reverse) {
    assertNotInfinite(collection.size);
    collection.__iterate(function (v, k, c) {
      if (useFirst) {
        useFirst = false;
        reduction = v;
      } else {
        reduction = reducer.call(context, reduction, v, k, c);
      }
    }, reverse);
    return reduction;
  }

  function keyMapper(v, k) {
    return k;
  }

  function entryMapper(v, k) {
    return [k, v];
  }

  function not(predicate) {
    return function () {
      return !predicate.apply(this, arguments);
    };
  }

  function neg(predicate) {
    return function () {
      return -predicate.apply(this, arguments);
    };
  }

  function defaultZipper() {
    return arrCopy(arguments);
  }

  function defaultNegComparator(a, b) {
    return a < b ? 1 : a > b ? -1 : 0;
  }

  function hashCollection(collection) {
    if (collection.size === Infinity) {
      return 0;
    }
    var ordered = isOrdered(collection);
    var keyed = isKeyed(collection);
    var h = ordered ? 1 : 0;
    var size = collection.__iterate(
      keyed
        ? ordered
          ? function (v, k) {
              h = (31 * h + hashMerge(hash(v), hash(k))) | 0;
            }
          : function (v, k) {
              h = (h + hashMerge(hash(v), hash(k))) | 0;
            }
        : ordered
        ? function (v) {
            h = (31 * h + hash(v)) | 0;
          }
        : function (v) {
            h = (h + hash(v)) | 0;
          }
    );
    return murmurHashOfSize(size, h);
  }

  function murmurHashOfSize(size, h) {
    h = imul(h, 0xcc9e2d51);
    h = imul((h << 15) | (h >>> -15), 0x1b873593);
    h = imul((h << 13) | (h >>> -13), 5);
    h = ((h + 0xe6546b64) | 0) ^ size;
    h = imul(h ^ (h >>> 16), 0x85ebca6b);
    h = imul(h ^ (h >>> 13), 0xc2b2ae35);
    h = smi(h ^ (h >>> 16));
    return h;
  }

  function hashMerge(a, b) {
    return (a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2))) | 0; // int
  }

  var OrderedSet = /*@__PURE__*/(function (Set) {
    function OrderedSet(value) {
      return value === undefined || value === null
        ? emptyOrderedSet()
        : isOrderedSet(value)
        ? value
        : emptyOrderedSet().withMutations(function (set) {
            var iter = SetCollection(value);
            assertNotInfinite(iter.size);
            iter.forEach(function (v) { return set.add(v); });
          });
    }

    if ( Set ) OrderedSet.__proto__ = Set;
    OrderedSet.prototype = Object.create( Set && Set.prototype );
    OrderedSet.prototype.constructor = OrderedSet;

    OrderedSet.of = function of (/*...values*/) {
      return this(arguments);
    };

    OrderedSet.fromKeys = function fromKeys (value) {
      return this(KeyedCollection(value).keySeq());
    };

    OrderedSet.prototype.toString = function toString () {
      return this.__toString('OrderedSet {', '}');
    };

    return OrderedSet;
  }(Set));

  OrderedSet.isOrderedSet = isOrderedSet;

  var OrderedSetPrototype = OrderedSet.prototype;
  OrderedSetPrototype[IS_ORDERED_SYMBOL] = true;
  OrderedSetPrototype.zip = IndexedCollectionPrototype.zip;
  OrderedSetPrototype.zipWith = IndexedCollectionPrototype.zipWith;
  OrderedSetPrototype.zipAll = IndexedCollectionPrototype.zipAll;

  OrderedSetPrototype.__empty = emptyOrderedSet;
  OrderedSetPrototype.__make = makeOrderedSet;

  function makeOrderedSet(map, ownerID) {
    var set = Object.create(OrderedSetPrototype);
    set.size = map ? map.size : 0;
    set._map = map;
    set.__ownerID = ownerID;
    return set;
  }

  var EMPTY_ORDERED_SET;
  function emptyOrderedSet() {
    return (
      EMPTY_ORDERED_SET || (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()))
    );
  }

  function throwOnInvalidDefaultValues(defaultValues) {
    if (isRecord(defaultValues)) {
      throw new Error(
        'Can not call `Record` with an immutable Record as default values. Use a plain javascript object instead.'
      );
    }

    if (isImmutable(defaultValues)) {
      throw new Error(
        'Can not call `Record` with an immutable Collection as default values. Use a plain javascript object instead.'
      );
    }

    if (defaultValues === null || typeof defaultValues !== 'object') {
      throw new Error(
        'Can not call `Record` with a non-object as default values. Use a plain javascript object instead.'
      );
    }
  }

  var Record = function Record(defaultValues, name) {
    var hasInitialized;

    throwOnInvalidDefaultValues(defaultValues);

    var RecordType = function Record(values) {
      var this$1$1 = this;

      if (values instanceof RecordType) {
        return values;
      }
      if (!(this instanceof RecordType)) {
        return new RecordType(values);
      }
      if (!hasInitialized) {
        hasInitialized = true;
        var keys = Object.keys(defaultValues);
        var indices = (RecordTypePrototype._indices = {});
        // Deprecated: left to attempt not to break any external code which
        // relies on a ._name property existing on record instances.
        // Use Record.getDescriptiveName() instead
        RecordTypePrototype._name = name;
        RecordTypePrototype._keys = keys;
        RecordTypePrototype._defaultValues = defaultValues;
        for (var i = 0; i < keys.length; i++) {
          var propName = keys[i];
          indices[propName] = i;
          if (RecordTypePrototype[propName]) {
            /* eslint-disable no-console */
            typeof console === 'object' &&
              console.warn &&
              console.warn(
                'Cannot define ' +
                  recordName(this) +
                  ' with property "' +
                  propName +
                  '" since that property name is part of the Record API.'
              );
            /* eslint-enable no-console */
          } else {
            setProp(RecordTypePrototype, propName);
          }
        }
      }
      this.__ownerID = undefined;
      this._values = List().withMutations(function (l) {
        l.setSize(this$1$1._keys.length);
        KeyedCollection(values).forEach(function (v, k) {
          l.set(this$1$1._indices[k], v === this$1$1._defaultValues[k] ? undefined : v);
        });
      });
      return this;
    };

    var RecordTypePrototype = (RecordType.prototype =
      Object.create(RecordPrototype));
    RecordTypePrototype.constructor = RecordType;

    if (name) {
      RecordType.displayName = name;
    }

    return RecordType;
  };

  Record.prototype.toString = function toString () {
    var str = recordName(this) + ' { ';
    var keys = this._keys;
    var k;
    for (var i = 0, l = keys.length; i !== l; i++) {
      k = keys[i];
      str += (i ? ', ' : '') + k + ': ' + quoteString(this.get(k));
    }
    return str + ' }';
  };

  Record.prototype.equals = function equals (other) {
    return (
      this === other ||
      (isRecord(other) && recordSeq(this).equals(recordSeq(other)))
    );
  };

  Record.prototype.hashCode = function hashCode () {
    return recordSeq(this).hashCode();
  };

  // @pragma Access

  Record.prototype.has = function has (k) {
    return this._indices.hasOwnProperty(k);
  };

  Record.prototype.get = function get (k, notSetValue) {
    if (!this.has(k)) {
      return notSetValue;
    }
    var index = this._indices[k];
    var value = this._values.get(index);
    return value === undefined ? this._defaultValues[k] : value;
  };

  // @pragma Modification

  Record.prototype.set = function set (k, v) {
    if (this.has(k)) {
      var newValues = this._values.set(
        this._indices[k],
        v === this._defaultValues[k] ? undefined : v
      );
      if (newValues !== this._values && !this.__ownerID) {
        return makeRecord(this, newValues);
      }
    }
    return this;
  };

  Record.prototype.remove = function remove (k) {
    return this.set(k);
  };

  Record.prototype.clear = function clear () {
    var newValues = this._values.clear().setSize(this._keys.length);

    return this.__ownerID ? this : makeRecord(this, newValues);
  };

  Record.prototype.wasAltered = function wasAltered () {
    return this._values.wasAltered();
  };

  Record.prototype.toSeq = function toSeq () {
    return recordSeq(this);
  };

  Record.prototype.toJS = function toJS$1 () {
    return toJS(this);
  };

  Record.prototype.entries = function entries () {
    return this.__iterator(ITERATE_ENTRIES);
  };

  Record.prototype.__iterator = function __iterator (type, reverse) {
    return recordSeq(this).__iterator(type, reverse);
  };

  Record.prototype.__iterate = function __iterate (fn, reverse) {
    return recordSeq(this).__iterate(fn, reverse);
  };

  Record.prototype.__ensureOwner = function __ensureOwner (ownerID) {
    if (ownerID === this.__ownerID) {
      return this;
    }
    var newValues = this._values.__ensureOwner(ownerID);
    if (!ownerID) {
      this.__ownerID = ownerID;
      this._values = newValues;
      return this;
    }
    return makeRecord(this, newValues, ownerID);
  };

  Record.isRecord = isRecord;
  Record.getDescriptiveName = recordName;
  var RecordPrototype = Record.prototype;
  RecordPrototype[IS_RECORD_SYMBOL] = true;
  RecordPrototype[DELETE] = RecordPrototype.remove;
  RecordPrototype.deleteIn = RecordPrototype.removeIn = deleteIn;
  RecordPrototype.getIn = getIn;
  RecordPrototype.hasIn = CollectionPrototype.hasIn;
  RecordPrototype.merge = merge$1;
  RecordPrototype.mergeWith = mergeWith$1;
  RecordPrototype.mergeIn = mergeIn;
  RecordPrototype.mergeDeep = mergeDeep;
  RecordPrototype.mergeDeepWith = mergeDeepWith;
  RecordPrototype.mergeDeepIn = mergeDeepIn;
  RecordPrototype.setIn = setIn;
  RecordPrototype.update = update;
  RecordPrototype.updateIn = updateIn;
  RecordPrototype.withMutations = withMutations;
  RecordPrototype.asMutable = asMutable;
  RecordPrototype.asImmutable = asImmutable;
  RecordPrototype[ITERATOR_SYMBOL] = RecordPrototype.entries;
  RecordPrototype.toJSON = RecordPrototype.toObject =
    CollectionPrototype.toObject;
  RecordPrototype.inspect = RecordPrototype.toSource = function () {
    return this.toString();
  };

  function makeRecord(likeRecord, values, ownerID) {
    var record = Object.create(Object.getPrototypeOf(likeRecord));
    record._values = values;
    record.__ownerID = ownerID;
    return record;
  }

  function recordName(record) {
    return record.constructor.displayName || record.constructor.name || 'Record';
  }

  function recordSeq(record) {
    return keyedSeqFromValue(record._keys.map(function (k) { return [k, record.get(k)]; }));
  }

  function setProp(prototype, name) {
    try {
      Object.defineProperty(prototype, name, {
        get: function () {
          return this.get(name);
        },
        set: function (value) {
          invariant(this.__ownerID, 'Cannot set on an immutable record.');
          this.set(name, value);
        },
      });
    } catch (error) {
      // Object.defineProperty failed. Probably IE8.
    }
  }

  /**
   * Returns a lazy Seq of `value` repeated `times` times. When `times` is
   * undefined, returns an infinite sequence of `value`.
   */
  var Repeat = /*@__PURE__*/(function (IndexedSeq) {
    function Repeat(value, times) {
      if (!(this instanceof Repeat)) {
        return new Repeat(value, times);
      }
      this._value = value;
      this.size = times === undefined ? Infinity : Math.max(0, times);
      if (this.size === 0) {
        if (EMPTY_REPEAT) {
          return EMPTY_REPEAT;
        }
        EMPTY_REPEAT = this;
      }
    }

    if ( IndexedSeq ) Repeat.__proto__ = IndexedSeq;
    Repeat.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );
    Repeat.prototype.constructor = Repeat;

    Repeat.prototype.toString = function toString () {
      if (this.size === 0) {
        return 'Repeat []';
      }
      return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]';
    };

    Repeat.prototype.get = function get (index, notSetValue) {
      return this.has(index) ? this._value : notSetValue;
    };

    Repeat.prototype.includes = function includes (searchValue) {
      return is(this._value, searchValue);
    };

    Repeat.prototype.slice = function slice (begin, end) {
      var size = this.size;
      return wholeSlice(begin, end, size)
        ? this
        : new Repeat(
            this._value,
            resolveEnd(end, size) - resolveBegin(begin, size)
          );
    };

    Repeat.prototype.reverse = function reverse () {
      return this;
    };

    Repeat.prototype.indexOf = function indexOf (searchValue) {
      if (is(this._value, searchValue)) {
        return 0;
      }
      return -1;
    };

    Repeat.prototype.lastIndexOf = function lastIndexOf (searchValue) {
      if (is(this._value, searchValue)) {
        return this.size;
      }
      return -1;
    };

    Repeat.prototype.__iterate = function __iterate (fn, reverse) {
      var size = this.size;
      var i = 0;
      while (i !== size) {
        if (fn(this._value, reverse ? size - ++i : i++, this) === false) {
          break;
        }
      }
      return i;
    };

    Repeat.prototype.__iterator = function __iterator (type, reverse) {
      var this$1$1 = this;

      var size = this.size;
      var i = 0;
      return new Iterator(function () { return i === size
          ? iteratorDone()
          : iteratorValue(type, reverse ? size - ++i : i++, this$1$1._value); }
      );
    };

    Repeat.prototype.equals = function equals (other) {
      return other instanceof Repeat
        ? is(this._value, other._value)
        : deepEqual(other);
    };

    return Repeat;
  }(IndexedSeq));

  var EMPTY_REPEAT;

  function fromJS(value, converter) {
    return fromJSWith(
      [],
      converter || defaultConverter,
      value,
      '',
      converter && converter.length > 2 ? [] : undefined,
      { '': value }
    );
  }

  function fromJSWith(stack, converter, value, key, keyPath, parentValue) {
    if (
      typeof value !== 'string' &&
      !isImmutable(value) &&
      (isArrayLike(value) || hasIterator(value) || isPlainObject(value))
    ) {
      if (~stack.indexOf(value)) {
        throw new TypeError('Cannot convert circular structure to Immutable');
      }
      stack.push(value);
      keyPath && key !== '' && keyPath.push(key);
      var converted = converter.call(
        parentValue,
        key,
        Seq(value).map(function (v, k) { return fromJSWith(stack, converter, v, k, keyPath, value); }
        ),
        keyPath && keyPath.slice()
      );
      stack.pop();
      keyPath && keyPath.pop();
      return converted;
    }
    return value;
  }

  function defaultConverter(k, v) {
    // Effectively the opposite of "Collection.toSeq()"
    return isIndexed(v) ? v.toList() : isKeyed(v) ? v.toMap() : v.toSet();
  }

  var version = "4.1.0";

  var Immutable = {
    version: version,

    Collection: Collection,
    // Note: Iterable is deprecated
    Iterable: Collection,

    Seq: Seq,
    Map: Map,
    OrderedMap: OrderedMap,
    List: List,
    Stack: Stack,
    Set: Set,
    OrderedSet: OrderedSet,

    Record: Record,
    Range: Range,
    Repeat: Repeat,

    is: is,
    fromJS: fromJS,
    hash: hash,

    isImmutable: isImmutable,
    isCollection: isCollection,
    isKeyed: isKeyed,
    isIndexed: isIndexed,
    isAssociative: isAssociative,
    isOrdered: isOrdered,
    isValueObject: isValueObject,
    isPlainObject: isPlainObject,
    isSeq: isSeq,
    isList: isList,
    isMap: isMap,
    isOrderedMap: isOrderedMap,
    isStack: isStack,
    isSet: isSet,
    isOrderedSet: isOrderedSet,
    isRecord: isRecord,

    get: get,
    getIn: getIn$1,
    has: has,
    hasIn: hasIn$1,
    merge: merge,
    mergeDeep: mergeDeep$1,
    mergeWith: mergeWith,
    mergeDeepWith: mergeDeepWith$1,
    remove: remove,
    removeIn: removeIn,
    set: set,
    setIn: setIn$1,
    update: update$1,
    updateIn: updateIn$1,
  };

  // Note: Iterable is deprecated
  var Iterable = Collection;

  exports.Collection = Collection;
  exports.Iterable = Iterable;
  exports.List = List;
  exports.Map = Map;
  exports.OrderedMap = OrderedMap;
  exports.OrderedSet = OrderedSet;
  exports.Range = Range;
  exports.Record = Record;
  exports.Repeat = Repeat;
  exports.Seq = Seq;
  exports.Set = Set;
  exports.Stack = Stack;
  exports.default = Immutable;
  exports.fromJS = fromJS;
  exports.get = get;
  exports.getIn = getIn$1;
  exports.has = has;
  exports.hasIn = hasIn$1;
  exports.hash = hash;
  exports.is = is;
  exports.isAssociative = isAssociative;
  exports.isCollection = isCollection;
  exports.isImmutable = isImmutable;
  exports.isIndexed = isIndexed;
  exports.isKeyed = isKeyed;
  exports.isList = isList;
  exports.isMap = isMap;
  exports.isOrdered = isOrdered;
  exports.isOrderedMap = isOrderedMap;
  exports.isOrderedSet = isOrderedSet;
  exports.isPlainObject = isPlainObject;
  exports.isRecord = isRecord;
  exports.isSeq = isSeq;
  exports.isSet = isSet;
  exports.isStack = isStack;
  exports.isValueObject = isValueObject;
  exports.merge = merge;
  exports.mergeDeep = mergeDeep$1;
  exports.mergeDeepWith = mergeDeepWith$1;
  exports.mergeWith = mergeWith;
  exports.remove = remove;
  exports.removeIn = removeIn;
  exports.set = set;
  exports.setIn = setIn$1;
  exports.update = update$1;
  exports.updateIn = updateIn$1;
  exports.version = version;

  Object.defineProperty(exports, '__esModule', { value: true });

})));

},{}],88:[function(require,module,exports){
if (typeof Object.create === 'function') {
  // implementation from standard node.js 'util' module
  module.exports = function inherits(ctor, superCtor) {
    if (superCtor) {
      ctor.super_ = superCtor
      ctor.prototype = Object.create(superCtor.prototype, {
        constructor: {
          value: ctor,
          enumerable: false,
          writable: true,
          configurable: true
        }
      })
    }
  };
} else {
  // old school shim for old browsers
  module.exports = function inherits(ctor, superCtor) {
    if (superCtor) {
      ctor.super_ = superCtor
      var TempCtor = function () {}
      TempCtor.prototype = superCtor.prototype
      ctor.prototype = new TempCtor()
      ctor.prototype.constructor = ctor
    }
  }
}

},{}],89:[function(require,module,exports){
module.exports = require('../impls/$append/append.js').__append;
},{"../impls/$append/append.js":256}],90:[function(require,module,exports){
module.exports = require('../impls/apply/apply.js').__apply;
},{"../impls/apply/apply.js":414}],91:[function(require,module,exports){
module.exports = require('../impls/array-reverse/array-reverse.js').__arrayReverse;
},{"../impls/array-reverse/array-reverse.js":421}],92:[function(require,module,exports){
module.exports = require('../impls/$append/async-append.js').__asyncAppend;
},{"../impls/$append/async-append.js":257}],93:[function(require,module,exports){
module.exports = require('../impls/$batch/async-batch.js').__asyncBatch;
},{"../impls/$batch/async-batch.js":258}],94:[function(require,module,exports){
module.exports = require('../impls/$bisect/async-bisect.js').__asyncBisect;
},{"../impls/$bisect/async-bisect.js":260}],95:[function(require,module,exports){
module.exports = require('../impls/async-buffer/async-buffer.js').__asyncBuffer;
},{"../impls/async-buffer/async-buffer.js":422}],96:[function(require,module,exports){
module.exports = require('../impls/$collate/async-collate.js').__asyncCollate;
},{"../impls/$collate/async-collate.js":262}],97:[function(require,module,exports){
module.exports = require('../impls/$compress/async-compress.js').__asyncCompress;
},{"../impls/$compress/async-compress.js":264}],98:[function(require,module,exports){
module.exports = require('../impls/$concat/async-concat.js').__asyncConcat;
},{"../impls/$concat/async-concat.js":266}],99:[function(require,module,exports){
module.exports = require('../impls/$consume/async-consume.js').__asyncConsume;
},{"../impls/$consume/async-consume.js":268}],100:[function(require,module,exports){
module.exports = require('../impls/$cycle-times/async-cycle-times.js').__asyncCycleTimes;
},{"../impls/$cycle-times/async-cycle-times.js":270}],101:[function(require,module,exports){
module.exports = require('../impls/$cycle/async-cycle.js').__asyncCycle;
},{"../impls/$cycle/async-cycle.js":272}],102:[function(require,module,exports){
module.exports = require('../impls/$deep-equal/async-deep-equal.js').__asyncDeepEqual;
},{"../impls/$deep-equal/async-deep-equal.js":274}],103:[function(require,module,exports){
module.exports = require('../impls/$distinct/async-distinct.js').__asyncDistinct;
},{"../impls/$distinct/async-distinct.js":276}],104:[function(require,module,exports){
module.exports = require('../impls/$drop-while/async-drop-while.js').__asyncDropWhile;
},{"../impls/$drop-while/async-drop-while.js":278}],105:[function(require,module,exports){
module.exports = require('../impls/$drop/async-drop.js').__asyncDrop;
},{"../impls/$drop/async-drop.js":280}],106:[function(require,module,exports){
module.exports = require('../impls/$enumerate/async-enumerate.js').__asyncEnumerate;
},{"../impls/$enumerate/async-enumerate.js":282}],107:[function(require,module,exports){
module.exports = require('../impls/$equal/async-equal.js').__asyncEqual;
},{"../impls/$equal/async-equal.js":284}],108:[function(require,module,exports){
module.exports = require('../impls/$every/async-every.js').__asyncEvery;
},{"../impls/$every/async-every.js":286}],109:[function(require,module,exports){
module.exports = require('../impls/$filter/async-filter.js').__asyncFilter;
},{"../impls/$filter/async-filter.js":288}],110:[function(require,module,exports){
module.exports = require('../impls/$find-best-or/async-find-best-or.js').__asyncFindBestOr;
},{"../impls/$find-best-or/async-find-best-or.js":290}],111:[function(require,module,exports){
module.exports = require('../impls/$find-best/async-find-best.js').__asyncFindBest;
},{"../impls/$find-best/async-find-best.js":292}],112:[function(require,module,exports){
module.exports = require('../impls/$find-or/async-find-or.js').__asyncFindOr;
},{"../impls/$find-or/async-find-or.js":294}],113:[function(require,module,exports){
module.exports = require('../impls/$find/async-find.js').__asyncFind;
},{"../impls/$find/async-find.js":296}],114:[function(require,module,exports){
module.exports = require('../impls/$first-or/async-first-or.js').__asyncFirstOr;
},{"../impls/$first-or/async-first-or.js":298}],115:[function(require,module,exports){
module.exports = require('../impls/$first/async-first.js').__asyncFirst;
},{"../impls/$first/async-first.js":300}],116:[function(require,module,exports){
module.exports = require('../impls/$flat-map/async-flat-map.js').__asyncFlatMap;
},{"../impls/$flat-map/async-flat-map.js":302}],117:[function(require,module,exports){
module.exports = require('../impls/$flat/async-flat.js').__asyncFlat;
},{"../impls/$flat/async-flat.js":304}],118:[function(require,module,exports){
module.exports = require('../impls/$for-each/async-for-each.js').__asyncForEach;
},{"../impls/$for-each/async-for-each.js":307}],119:[function(require,module,exports){
module.exports = require('../impls/$fork/async-fork.js').__asyncFork;
},{"../impls/$fork/async-fork.js":309}],120:[function(require,module,exports){
module.exports = require('../impls/$forkerate/async-forkerate.js').__asyncForkerate;
},{"../impls/$forkerate/async-forkerate.js":311}],121:[function(require,module,exports){
module.exports = require('../impls/$includes-any-seq/async-includes-any-seq.js').__asyncIncludesAnySeq;
},{"../impls/$includes-any-seq/async-includes-any-seq.js":313}],122:[function(require,module,exports){
module.exports = require('../impls/$includes-any/async-includes-any.js').__asyncIncludesAny;
},{"../impls/$includes-any/async-includes-any.js":315}],123:[function(require,module,exports){
module.exports = require('../impls/$includes-seq/async-includes-seq.js').__asyncIncludesSeq;
},{"../impls/$includes-seq/async-includes-seq.js":317}],124:[function(require,module,exports){
module.exports = require('../impls/$includes/async-includes.js').__asyncIncludes;
},{"../impls/$includes/async-includes.js":319}],125:[function(require,module,exports){
module.exports = require('../impls/async-interleave-ready/async-interleave-ready.js').__asyncInterleaveReady;
},{"../impls/async-interleave-ready/async-interleave-ready.js":423}],126:[function(require,module,exports){
module.exports = require('../impls/$interleave/async-interleave.js').__asyncInterleave;
},{"../impls/$interleave/async-interleave.js":321}],127:[function(require,module,exports){
module.exports = require('../impls/$interpose-seq/async-interpose-seq.js').__asyncInterposeSeq;
},{"../impls/$interpose-seq/async-interpose-seq.js":323}],128:[function(require,module,exports){
module.exports = require('../impls/$interpose/async-interpose.js').__asyncInterpose;
},{"../impls/$interpose/async-interpose.js":325}],129:[function(require,module,exports){
module.exports = require('../impls/$is-empty/async-is-empty.js').__asyncIsEmpty;
},{"../impls/$is-empty/async-is-empty.js":327}],130:[function(require,module,exports){
module.exports = require('../impls/$is-sorted/async-is-sorted.js').__asyncIsSorted;
},{"../impls/$is-sorted/async-is-sorted.js":329}],131:[function(require,module,exports){
module.exports = require('../impls/$join-with-seq/async-join-with-seq.js').__asyncJoinWithSeq;
},{"../impls/$join-with-seq/async-join-with-seq.js":331}],132:[function(require,module,exports){
module.exports = require('../impls/$join-with/async-join-with.js').__asyncJoinWith;
},{"../impls/$join-with/async-join-with.js":333}],133:[function(require,module,exports){
module.exports = require('../impls/$join/async-join.js').__asyncJoin;
},{"../impls/$join/async-join.js":335}],134:[function(require,module,exports){
module.exports = require('../impls/$map/async-map.js').__asyncMap;
},{"../impls/$map/async-map.js":337}],135:[function(require,module,exports){
module.exports = require('../impls/$peekerate/async-peekerate.js').__asyncPeekerate;
},{"../impls/$peekerate/async-peekerate.js":339}],136:[function(require,module,exports){
module.exports = require('../impls/$prepend/async-prepend.js').__asyncPrepend;
},{"../impls/$prepend/async-prepend.js":341}],137:[function(require,module,exports){
module.exports = require('../impls/$reduce/async-reduce.js').__asyncReduce;
},{"../impls/$reduce/async-reduce.js":343}],138:[function(require,module,exports){
module.exports = require('../impls/$reverse/async-reverse.js').__asyncReverse;
},{"../impls/$reverse/async-reverse.js":345}],139:[function(require,module,exports){
module.exports = require('../impls/$round-robin/async-round-robin.js').__asyncRoundRobin;
},{"../impls/$round-robin/async-round-robin.js":347}],140:[function(require,module,exports){
module.exports = require('../impls/$size/async-size.js').__asyncSize;
},{"../impls/$size/async-size.js":350}],141:[function(require,module,exports){
module.exports = require('../impls/$slice/async-slice.js').__asyncSliceFromStart;
},{"../impls/$slice/async-slice.js":352}],142:[function(require,module,exports){
module.exports = require('../impls/$some/async-some.js').__asyncSome;
},{"../impls/$some/async-some.js":355}],143:[function(require,module,exports){
module.exports = require('../impls/$split-groups/async-split-groups.js').__asyncSplitGroups;
},{"../impls/$split-groups/async-split-groups.js":357}],144:[function(require,module,exports){
module.exports = require('../impls/$split-on-any-seq/async-split-on-any-seq.js').__asyncSplitOnAnySeq;
},{"../impls/$split-on-any-seq/async-split-on-any-seq.js":359}],145:[function(require,module,exports){
module.exports = require('../impls/$split-on-any/async-split-on-any.js').__asyncSplitOnAny;
},{"../impls/$split-on-any/async-split-on-any.js":361}],146:[function(require,module,exports){
module.exports = require('../impls/$split-on-seq/async-split-on-seq.js').__asyncSplitOnSeq;
},{"../impls/$split-on-seq/async-split-on-seq.js":363}],147:[function(require,module,exports){
module.exports = require('../impls/$split-on/async-split-on.js').__asyncSplitOn;
},{"../impls/$split-on/async-split-on.js":365}],148:[function(require,module,exports){
module.exports = require('../impls/$split-when/async-split-when.js').__asyncSplitWhen;
},{"../impls/$split-when/async-split-when.js":367}],149:[function(require,module,exports){
module.exports = require('../impls/$split/async-split.js').__asyncSplit;
},{"../impls/$split/async-split.js":369}],150:[function(require,module,exports){
module.exports = require('../impls/$spliterate-grouped/async-spliterate-grouped.js').__asyncSpliterateGrouped;
},{"../impls/$spliterate-grouped/async-spliterate-grouped.js":371}],151:[function(require,module,exports){
module.exports = require('../impls/$spliterate/async-spliterate.js').__asyncSpliterate;
},{"../impls/$spliterate/async-spliterate.js":373}],152:[function(require,module,exports){
module.exports = require('../impls/$starts-with-any-seq/async-starts-with-any-seq.js').__asyncStartsWithAnySeq;
},{"../impls/$starts-with-any-seq/async-starts-with-any-seq.js":375}],153:[function(require,module,exports){
module.exports = require('../impls/$starts-with-any/async-starts-with-any.js').__asyncStartsWithAny;
},{"../impls/$starts-with-any/async-starts-with-any.js":377}],154:[function(require,module,exports){
module.exports = require('../impls/$starts-with-seq/async-starts-with-seq.js').__asyncStartsWithSeq;
},{"../impls/$starts-with-seq/async-starts-with-seq.js":379}],155:[function(require,module,exports){
module.exports = require('../impls/$starts-with/async-starts-with.js').__asyncStartsWith;
},{"../impls/$starts-with/async-starts-with.js":381}],156:[function(require,module,exports){
module.exports = require('../impls/$str/async-str.js').__asyncStr;
},{"../impls/$str/async-str.js":383}],157:[function(require,module,exports){
module.exports = require('../impls/$take-last-or/async-take-last-or.js').__asyncTakeLastOr;
},{"../impls/$take-last-or/async-take-last-or.js":385}],158:[function(require,module,exports){
module.exports = require('../impls/$take-last/async-take-last.js').__asyncTakeLast;
},{"../impls/$take-last/async-take-last.js":387}],159:[function(require,module,exports){
module.exports = require('../impls/$take-sorted/async-take-sorted.js').__asyncTakeSorted;
},{"../impls/$take-sorted/async-take-sorted.js":389}],160:[function(require,module,exports){
module.exports = require('../impls/$take-while/async-take-while.js').__asyncTakeWhile;
},{"../impls/$take-while/async-take-while.js":392}],161:[function(require,module,exports){
module.exports = require('../impls/$take/async-take.js').__asyncTake;
},{"../impls/$take/async-take.js":394}],162:[function(require,module,exports){
module.exports = require('../impls/$tap/async-tap.js').__asyncTap;
},{"../impls/$tap/async-tap.js":396}],163:[function(require,module,exports){
module.exports = require('../impls/async-throttle/async-throttle.js').__asyncThrottle;
},{"../impls/async-throttle/async-throttle.js":425}],164:[function(require,module,exports){
module.exports = require('../impls/$to-array/async-to-array.js').__asyncToArray;
},{"../impls/$to-array/async-to-array.js":398}],165:[function(require,module,exports){
module.exports = require('../impls/$to-object/async-to-object.js').__asyncToObject;
},{"../impls/$to-object/async-to-object.js":400}],166:[function(require,module,exports){
module.exports = require('../impls/$window-ahead/async-window-ahead.js').__asyncWindowAhead;
},{"../impls/$window-ahead/async-window-ahead.js":402}],167:[function(require,module,exports){
module.exports = require('../impls/$window-behind/async-window-behind.js').__asyncWindowBehind;
},{"../impls/$window-behind/async-window-behind.js":404}],168:[function(require,module,exports){
module.exports = require('../impls/$window/async-window.js').__asyncWindow;
},{"../impls/$window/async-window.js":406}],169:[function(require,module,exports){
module.exports = require('../impls/$zip-all/async-zip-all.js').__asyncZipAll;
},{"../impls/$zip-all/async-zip-all.js":410}],170:[function(require,module,exports){
module.exports = require('../impls/$zip/async-zip.js').__asyncZip;
},{"../impls/$zip/async-zip.js":412}],171:[function(require,module,exports){
module.exports = require('../impls/$batch/batch.js').__batch;
},{"../impls/$batch/batch.js":259}],172:[function(require,module,exports){
module.exports = require('../impls/$bisect/bisect.js').__bisect;
},{"../impls/$bisect/bisect.js":261}],173:[function(require,module,exports){
module.exports = require('../impls/call/call.js').__call;
},{"../impls/call/call.js":426}],174:[function(require,module,exports){
module.exports = require('../impls/$collate/collate.js').__collate;
},{"../impls/$collate/collate.js":263}],175:[function(require,module,exports){
module.exports = require('../impls/$compress/compress.js').__compress;
},{"../impls/$compress/compress.js":265}],176:[function(require,module,exports){
module.exports = require('../impls/$concat/concat.js').__concat;
},{"../impls/$concat/concat.js":267}],177:[function(require,module,exports){
module.exports = require('../impls/$consume/consume.js').__consume;
},{"../impls/$consume/consume.js":269}],178:[function(require,module,exports){
module.exports = require('../impls/$cycle-times/cycle-times.js').__cycleTimes;
},{"../impls/$cycle-times/cycle-times.js":271}],179:[function(require,module,exports){
module.exports = require('../impls/$cycle/cycle.js').__cycle;
},{"../impls/$cycle/cycle.js":273}],180:[function(require,module,exports){
module.exports = require('../impls/$deep-equal/deep-equal.js').__deepEqual;
},{"../impls/$deep-equal/deep-equal.js":275}],181:[function(require,module,exports){
module.exports = require('../impls/$distinct/distinct.js').__distinct;
},{"../impls/$distinct/distinct.js":277}],182:[function(require,module,exports){
module.exports = require('../impls/$drop-while/drop-while.js').__dropWhile;
},{"../impls/$drop-while/drop-while.js":279}],183:[function(require,module,exports){
module.exports = require('../impls/$drop/drop.js').__drop;
},{"../impls/$drop/drop.js":281}],184:[function(require,module,exports){
module.exports = require('../impls/$enumerate/enumerate.js').__enumerate;
},{"../impls/$enumerate/enumerate.js":283}],185:[function(require,module,exports){
module.exports = require('../impls/$equal/equal.js').__equal;
},{"../impls/$equal/equal.js":285}],186:[function(require,module,exports){
module.exports = require('../impls/$every/every.js').__every;
},{"../impls/$every/every.js":287}],187:[function(require,module,exports){
module.exports = require('../impls/$filter/filter.js').__filter;
},{"../impls/$filter/filter.js":289}],188:[function(require,module,exports){
module.exports = require('../impls/$find-best-or/find-best-or.js').__findBestOr;
},{"../impls/$find-best-or/find-best-or.js":291}],189:[function(require,module,exports){
module.exports = require('../impls/$find-best/find-best.js').__findBest;
},{"../impls/$find-best/find-best.js":293}],190:[function(require,module,exports){
module.exports = require('../impls/$find-or/find-or.js').__findOr;
},{"../impls/$find-or/find-or.js":295}],191:[function(require,module,exports){
module.exports = require('../impls/$find/find.js').__find;
},{"../impls/$find/find.js":297}],192:[function(require,module,exports){
module.exports = require('../impls/$first-or/first-or.js').__firstOr;
},{"../impls/$first-or/first-or.js":299}],193:[function(require,module,exports){
module.exports = require('../impls/$first/first.js').__first;
},{"../impls/$first/first.js":301}],194:[function(require,module,exports){
module.exports = require('../impls/$flat-map/flat-map.js').__flatMap;
},{"../impls/$flat-map/flat-map.js":303}],195:[function(require,module,exports){
module.exports = require('../impls/$flat/flat.js').__flat;
},{"../impls/$flat/flat.js":305}],196:[function(require,module,exports){
module.exports = require('../impls/$for-each/for-each.js').__forEach;
},{"../impls/$for-each/for-each.js":308}],197:[function(require,module,exports){
module.exports = require('../impls/$fork/fork.js').__fork;
},{"../impls/$fork/fork.js":310}],198:[function(require,module,exports){
module.exports = require('../impls/$forkerate/forkerate.js').__forkerate;
},{"../impls/$forkerate/forkerate.js":312}],199:[function(require,module,exports){
module.exports = require('../impls/$includes-any-seq/includes-any-seq.js').__includesAnySeq;
},{"../impls/$includes-any-seq/includes-any-seq.js":314}],200:[function(require,module,exports){
module.exports = require('../impls/$includes-any/includes-any.js').__includesAny;
},{"../impls/$includes-any/includes-any.js":316}],201:[function(require,module,exports){
module.exports = require('../impls/$includes-seq/includes-seq.js').__includesSeq;
},{"../impls/$includes-seq/includes-seq.js":318}],202:[function(require,module,exports){
module.exports = require('../impls/$includes/includes.js').__includes;
},{"../impls/$includes/includes.js":320}],203:[function(require,module,exports){
module.exports = require('../impls/$interleave/interleave.js').__interleave;
},{"../impls/$interleave/interleave.js":322}],204:[function(require,module,exports){
module.exports = require('../impls/$interpose-seq/interpose-seq.js').__interposeSeq;
},{"../impls/$interpose-seq/interpose-seq.js":324}],205:[function(require,module,exports){
module.exports = require('../impls/$interpose/interpose.js').__interpose;
},{"../impls/$interpose/interpose.js":326}],206:[function(require,module,exports){
module.exports = require('../impls/$is-empty/is-empty.js').__isEmpty;
},{"../impls/$is-empty/is-empty.js":328}],207:[function(require,module,exports){
module.exports = require('../impls/$is-sorted/is-sorted.js').__isSorted;
},{"../impls/$is-sorted/is-sorted.js":330}],208:[function(require,module,exports){
module.exports = require('../impls/$join-with-seq/join-with-seq.js').__joinWithSeq;
},{"../impls/$join-with-seq/join-with-seq.js":332}],209:[function(require,module,exports){
module.exports = require('../impls/$join-with/join-with.js').__joinWith;
},{"../impls/$join-with/join-with.js":334}],210:[function(require,module,exports){
module.exports = require('../impls/$join/join.js').__join;
},{"../impls/$join/join.js":336}],211:[function(require,module,exports){
module.exports = require('../impls/$map/map.js').__map;
},{"../impls/$map/map.js":338}],212:[function(require,module,exports){
module.exports = require('../impls/object-entries/object-entries.js').__objectEntries;
},{"../impls/object-entries/object-entries.js":458}],213:[function(require,module,exports){
module.exports = require('../impls/object-keys/object-keys.js').__objectKeys;
},{"../impls/object-keys/object-keys.js":461}],214:[function(require,module,exports){
module.exports = require('../impls/object-values/object-values.js').__objectValues;
},{"../impls/object-values/object-values.js":462}],215:[function(require,module,exports){
module.exports = require('../impls/$peekerate/peekerate.js').__peekerate;
},{"../impls/$peekerate/peekerate.js":340}],216:[function(require,module,exports){
module.exports = require('../impls/$prepend/prepend.js').__prepend;
},{"../impls/$prepend/prepend.js":342}],217:[function(require,module,exports){
module.exports = require('../impls/range/range.js').__range;
},{"../impls/range/range.js":464}],218:[function(require,module,exports){
module.exports = require('../impls/$reduce/reduce.js').__reduce;
},{"../impls/$reduce/reduce.js":344}],219:[function(require,module,exports){
module.exports = require('../impls/repeat-times/repeat-times.js').__repeatTimes;
},{"../impls/repeat-times/repeat-times.js":465}],220:[function(require,module,exports){
module.exports = require('../impls/repeat/repeat.js').__repeat;
},{"../impls/repeat/repeat.js":466}],221:[function(require,module,exports){
module.exports = require('../impls/$reverse/reverse.js').__reverse;
},{"../impls/$reverse/reverse.js":346}],222:[function(require,module,exports){
module.exports = require('../impls/$round-robin/round-robin.js').__roundRobin;
},{"../impls/$round-robin/round-robin.js":349}],223:[function(require,module,exports){
module.exports = require('../impls/$size/size.js').__size;
},{"../impls/$size/size.js":351}],224:[function(require,module,exports){
module.exports = require('../impls/$slice/slice.js').__sliceFromStart;
},{"../impls/$slice/slice.js":354}],225:[function(require,module,exports){
module.exports = require('../impls/$some/some.js').__some;
},{"../impls/$some/some.js":356}],226:[function(require,module,exports){
module.exports = require('../impls/$split-groups/split-groups.js').__splitGroups;
},{"../impls/$split-groups/split-groups.js":358}],227:[function(require,module,exports){
module.exports = require('../impls/$split-on-any-seq/split-on-any-seq.js').__splitOnAnySeq;
},{"../impls/$split-on-any-seq/split-on-any-seq.js":360}],228:[function(require,module,exports){
module.exports = require('../impls/$split-on-any/split-on-any.js').__splitOnAny;
},{"../impls/$split-on-any/split-on-any.js":362}],229:[function(require,module,exports){
module.exports = require('../impls/$split-on-seq/split-on-seq.js').__splitOnSeq;
},{"../impls/$split-on-seq/split-on-seq.js":364}],230:[function(require,module,exports){
module.exports = require('../impls/$split-on/split-on.js').__splitOn;
},{"../impls/$split-on/split-on.js":366}],231:[function(require,module,exports){
module.exports = require('../impls/$split-when/split-when.js').__splitWhen;
},{"../impls/$split-when/split-when.js":368}],232:[function(require,module,exports){
module.exports = require('../impls/$split/split.js').__split;
},{"../impls/$split/split.js":370}],233:[function(require,module,exports){
module.exports = require('../impls/$spliterate-grouped/spliterate-grouped.js').__spliterateGrouped;
},{"../impls/$spliterate-grouped/spliterate-grouped.js":372}],234:[function(require,module,exports){
module.exports = require('../impls/$spliterate/spliterate.js').__spliterate;
},{"../impls/$spliterate/spliterate.js":374}],235:[function(require,module,exports){
module.exports = require('../impls/$starts-with-any-seq/starts-with-any-seq.js').__startsWithAnySeq;
},{"../impls/$starts-with-any-seq/starts-with-any-seq.js":376}],236:[function(require,module,exports){
module.exports = require('../impls/$starts-with-any/starts-with-any.js').__startsWithAny;
},{"../impls/$starts-with-any/starts-with-any.js":378}],237:[function(require,module,exports){
module.exports = require('../impls/$starts-with-seq/starts-with-seq.js').__startsWithSeq;
},{"../impls/$starts-with-seq/starts-with-seq.js":380}],238:[function(require,module,exports){
module.exports = require('../impls/$starts-with/starts-with.js').__startsWith;
},{"../impls/$starts-with/starts-with.js":382}],239:[function(require,module,exports){
module.exports = require('../impls/$str/str.js').__str;
},{"../impls/$str/str.js":384}],240:[function(require,module,exports){
module.exports = require('../impls/$take-last-or/take-last-or.js').__takeLastOr;
},{"../impls/$take-last-or/take-last-or.js":386}],241:[function(require,module,exports){
module.exports = require('../impls/$take-last/take-last.js').__takeLast;
},{"../impls/$take-last/take-last.js":388}],242:[function(require,module,exports){
module.exports = require('../impls/$take-sorted/take-sorted.js').__takeSorted;
},{"../impls/$take-sorted/take-sorted.js":391}],243:[function(require,module,exports){
module.exports = require('../impls/$take-while/take-while.js').__takeWhile;
},{"../impls/$take-while/take-while.js":393}],244:[function(require,module,exports){
module.exports = require('../impls/$take/take.js').__take;
},{"../impls/$take/take.js":395}],245:[function(require,module,exports){
module.exports = require('../impls/$tap/tap.js').__tap;
},{"../impls/$tap/tap.js":397}],246:[function(require,module,exports){
module.exports = require('../impls/$to-array/to-array.js').__toArray;
},{"../impls/$to-array/to-array.js":399}],247:[function(require,module,exports){
module.exports = require('../impls/$to-object/to-object.js').__toObject;
},{"../impls/$to-object/to-object.js":401}],248:[function(require,module,exports){
module.exports = require('../impls/$window-ahead/window-ahead.js').__windowAhead;
},{"../impls/$window-ahead/window-ahead.js":403}],249:[function(require,module,exports){
module.exports = require('../impls/$window-behind/window-behind.js').__windowBehind;
},{"../impls/$window-behind/window-behind.js":405}],250:[function(require,module,exports){
module.exports = require('../impls/$window/window.js').__window;
},{"../impls/$window/window.js":407}],251:[function(require,module,exports){
module.exports = require('../impls/wrap-entries/wrap-entries.js').__wrapEntries;
},{"../impls/wrap-entries/wrap-entries.js":470}],252:[function(require,module,exports){
module.exports = require('../impls/wrap-keys/wrap-keys.js').__wrapKeys;
},{"../impls/wrap-keys/wrap-keys.js":471}],253:[function(require,module,exports){
module.exports = require('../impls/wrap-values/wrap-values.js').__wrapValues;
},{"../impls/wrap-values/wrap-values.js":472}],254:[function(require,module,exports){
module.exports = require('../impls/$zip-all/zip-all.js').__zipAll;
},{"../impls/$zip-all/zip-all.js":411}],255:[function(require,module,exports){
module.exports = require('../impls/$zip/zip.js').__zip;
},{"../impls/$zip/zip.js":413}],256:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__append);

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

function __append(source, value) {
  return _regeneratorRuntime.wrap(function __append$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          return _context.delegateYield(source, "t0", 1);

        case 1:
          _context.next = 3;
          return value;

        case 3:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

exports.__append = __append;
var append = /*#__PURE__*/iterableCurry(__append);
exports.append = append;
},{"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],257:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _asyncGeneratorDelegate = require("@babel/runtime/helpers/asyncGeneratorDelegate");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

function __asyncAppend(_x, _x2) {
  return _asyncAppend.apply(this, arguments);
}

exports.__asyncAppend = __asyncAppend;

function _asyncAppend() {
  _asyncAppend = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, value) {
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(source), _awaitAsyncGenerator), "t0", 1);

          case 1:
            _context.next = 3;
            return value;

          case 3:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncAppend.apply(this, arguments);
}

var asyncAppend = /*#__PURE__*/asyncIterableCurry(__asyncAppend);
exports.asyncAppend = asyncAppend;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncGeneratorDelegate":41,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],258:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$spliterate/async-spliterate.js'),
    __asyncSpliterate = _require2.__asyncSpliterate;

function asyncBatchSpliterator(_x, _x2, _x3) {
  return _asyncBatchSpliterator.apply(this, arguments);
}

function _asyncBatchSpliterator() {
  _asyncBatchSpliterator = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(split, _ref, source) {
    var size, i, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            size = _ref.size;
            i = 0;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 4;
            _iterator = _asyncIterator(source);

          case 6:
            _context.next = 8;
            return _awaitAsyncGenerator(_iterator.next());

          case 8:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 12;
            return _awaitAsyncGenerator(_step.value);

          case 12:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 25;
              break;
            }

            value = _value;

            if (!(i === size)) {
              _context.next = 19;
              break;
            }

            _context.next = 18;
            return split;

          case 18:
            i = 0;

          case 19:
            _context.next = 21;
            return value;

          case 21:
            i++;

          case 22:
            _iteratorNormalCompletion = true;
            _context.next = 6;
            break;

          case 25:
            _context.next = 31;
            break;

          case 27:
            _context.prev = 27;
            _context.t0 = _context["catch"](4);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 31:
            _context.prev = 31;
            _context.prev = 32;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 36;
              break;
            }

            _context.next = 36;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 36:
            _context.prev = 36;

            if (!_didIteratorError) {
              _context.next = 39;
              break;
            }

            throw _iteratorError;

          case 39:
            return _context.finish(36);

          case 40:
            return _context.finish(31);

          case 41:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[4, 27, 31, 41], [32,, 36, 40]]);
  }));
  return _asyncBatchSpliterator.apply(this, arguments);
}

function __asyncBatch(source, size) {
  return __asyncSpliterate(source, asyncBatchSpliterator, {
    size: size
  });
}

exports.__asyncBatch = __asyncBatch;
var asyncBatch = /*#__PURE__*/asyncIterableCurry(__asyncBatch, {
  validateArgs: function validateArgs(args) {
    if (typeof args[1] !== 'number' || args[1] < 1) {
      throw new TypeError('batch size should be a number greater than zero');
    }
  }
});
exports.asyncBatch = asyncBatch;
},{"../$spliterate/async-spliterate.js":373,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],259:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(batchSpliterator);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$spliterate/spliterate.js'),
    __spliterate = _require2.__spliterate;

function batchSpliterator(split, _ref, source) {
  var size, i, _iterator, _step, value;

  return _regeneratorRuntime.wrap(function batchSpliterator$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          size = _ref.size;
          i = 0;
          _iterator = _createForOfIteratorHelper(source);
          _context.prev = 3;

          _iterator.s();

        case 5:
          if ((_step = _iterator.n()).done) {
            _context.next = 16;
            break;
          }

          value = _step.value;

          if (!(i === size)) {
            _context.next = 11;
            break;
          }

          _context.next = 10;
          return split;

        case 10:
          i = 0;

        case 11:
          _context.next = 13;
          return value;

        case 13:
          i++;

        case 14:
          _context.next = 5;
          break;

        case 16:
          _context.next = 21;
          break;

        case 18:
          _context.prev = 18;
          _context.t0 = _context["catch"](3);

          _iterator.e(_context.t0);

        case 21:
          _context.prev = 21;

          _iterator.f();

          return _context.finish(21);

        case 24:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[3, 18, 21, 24]]);
}

function __batch(source, size) {
  return __spliterate(source, batchSpliterator, {
    size: size
  });
}

exports.__batch = __batch;
var batch = /*#__PURE__*/iterableCurry(__batch, {
  validateArgs: function validateArgs(args) {
    if (typeof args[1] !== 'number' || args[1] < 1) {
      throw new TypeError('batch size should be a number greater than zero');
    }
  }
});
exports.batch = batch;
},{"../$spliterate/spliterate.js":374,"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],260:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../../internal/async-bisector.js'),
    AsyncBisector = _require2.AsyncBisector;

var _require3 = require('../$to-array/async-to-array.js'),
    __asyncToArray = _require3.__asyncToArray;

var _require4 = require('../$peekerate/async-peekerate.js'),
    __asyncPeekerate = _require4.__asyncPeekerate;

function asyncIndexStrategy(_x, _x2, _x3) {
  return _asyncIndexStrategy.apply(this, arguments);
}

exports.asyncIndexStrategy = asyncIndexStrategy;

function _asyncIndexStrategy() {
  _asyncIndexStrategy = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(split, _ref, source) {
    var at, _source, idx, peekr;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            at = _ref.at;

            if (!(at < 0)) {
              _context.next = 7;
              break;
            }

            _context.next = 4;
            return _awaitAsyncGenerator(__asyncToArray(source));

          case 4:
            _context.t0 = _context.sent;
            _context.next = 8;
            break;

          case 7:
            _context.t0 = source;

          case 8:
            _source = _context.t0;
            idx = at < 0 ? _source.length + at : at;
            _context.next = 12;
            return _awaitAsyncGenerator(__asyncPeekerate(_source));

          case 12:
            peekr = _context.sent;
            _context.prev = 13;

          case 14:
            if (peekr.done) {
              _context.next = 24;
              break;
            }

            if (!(peekr.index === idx)) {
              _context.next = 18;
              break;
            }

            _context.next = 18;
            return split;

          case 18:
            _context.next = 20;
            return peekr.value;

          case 20:
            _context.next = 22;
            return _awaitAsyncGenerator(peekr.advance());

          case 22:
            _context.next = 14;
            break;

          case 24:
            _context.prev = 24;
            peekr["return"]();
            return _context.finish(24);

          case 27:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[13,, 24, 27]]);
  }));
  return _asyncIndexStrategy.apply(this, arguments);
}

function asyncConditionStrategy(_x4, _x5, _x6) {
  return _asyncConditionStrategy.apply(this, arguments);
}

exports.asyncConditionStrategy = asyncConditionStrategy;

function _asyncConditionStrategy() {
  _asyncConditionStrategy = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(split, _ref2, source) {
    var predicate, i, splat, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            predicate = _ref2.at;
            i = 0;
            splat = false;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context2.prev = 5;
            _iterator = _asyncIterator(source);

          case 7:
            _context2.next = 9;
            return _awaitAsyncGenerator(_iterator.next());

          case 9:
            _step = _context2.sent;
            _iteratorNormalCompletion = _step.done;
            _context2.next = 13;
            return _awaitAsyncGenerator(_step.value);

          case 13:
            _value = _context2.sent;

            if (_iteratorNormalCompletion) {
              _context2.next = 30;
              break;
            }

            value = _value;
            _context2.t0 = !splat;

            if (!_context2.t0) {
              _context2.next = 21;
              break;
            }

            _context2.next = 20;
            return _awaitAsyncGenerator(predicate(value, i++));

          case 20:
            _context2.t0 = _context2.sent;

          case 21:
            if (!_context2.t0) {
              _context2.next = 25;
              break;
            }

            _context2.next = 24;
            return split;

          case 24:
            splat = true;

          case 25:
            _context2.next = 27;
            return value;

          case 27:
            _iteratorNormalCompletion = true;
            _context2.next = 7;
            break;

          case 30:
            _context2.next = 36;
            break;

          case 32:
            _context2.prev = 32;
            _context2.t1 = _context2["catch"](5);
            _didIteratorError = true;
            _iteratorError = _context2.t1;

          case 36:
            _context2.prev = 36;
            _context2.prev = 37;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context2.next = 41;
              break;
            }

            _context2.next = 41;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 41:
            _context2.prev = 41;

            if (!_didIteratorError) {
              _context2.next = 44;
              break;
            }

            throw _iteratorError;

          case 44:
            return _context2.finish(41);

          case 45:
            return _context2.finish(36);

          case 46:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2, null, [[5, 32, 36, 46], [37,, 41, 45]]);
  }));
  return _asyncConditionStrategy.apply(this, arguments);
}

function __asyncBisect(source, at) {
  var strategy = typeof at === 'number' ? asyncIndexStrategy : asyncConditionStrategy;
  return new AsyncBisector(source, strategy, {
    at: at
  });
}

exports.__asyncBisect = __asyncBisect;
var asyncBisect = /*#__PURE__*/asyncIterableCurry(__asyncBisect, {
  forceSync: true
});
exports.asyncBisect = asyncBisect;
},{"../$peekerate/async-peekerate.js":339,"../$to-array/async-to-array.js":398,"../../internal/async-bisector.js":476,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],261:[function(require,module,exports){
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(indexStrategy),
    _marked2 = /*#__PURE__*/_regeneratorRuntime.mark(conditionStrategy);

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../../internal/bisector.js'),
    Bisector = _require2.Bisector;

var _require3 = require('../$to-array/to-array.js'),
    __toArray = _require3.__toArray;

var _require4 = require('../$peekerate/peekerate.js'),
    __peekerate = _require4.__peekerate;

function indexStrategy(split, _ref, source) {
  var at, _source, idx, peekr;

  return _regeneratorRuntime.wrap(function indexStrategy$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          at = _ref.at;
          _source = at < 0 ? __toArray(source) : source;
          idx = at < 0 ? _source.length + at : at;
          peekr = __peekerate(_source);
          _context.prev = 4;

        case 5:
          if (peekr.done) {
            _context.next = 14;
            break;
          }

          if (!(peekr.index === idx)) {
            _context.next = 9;
            break;
          }

          _context.next = 9;
          return split;

        case 9:
          _context.next = 11;
          return peekr.value;

        case 11:
          peekr.advance();
          _context.next = 5;
          break;

        case 14:
          _context.prev = 14;
          peekr["return"]();
          return _context.finish(14);

        case 17:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[4,, 14, 17]]);
}

exports.indexStrategy = indexStrategy;

function conditionStrategy(split, _ref2, source) {
  var predicate, i, splat, _iterator, _step, value;

  return _regeneratorRuntime.wrap(function conditionStrategy$(_context2) {
    while (1) {
      switch (_context2.prev = _context2.next) {
        case 0:
          predicate = _ref2.at;
          i = 0;
          splat = false;
          _iterator = _createForOfIteratorHelper(source);
          _context2.prev = 4;

          _iterator.s();

        case 6:
          if ((_step = _iterator.n()).done) {
            _context2.next = 16;
            break;
          }

          value = _step.value;

          if (!(!splat && predicate(value, i++))) {
            _context2.next = 12;
            break;
          }

          _context2.next = 11;
          return split;

        case 11:
          splat = true;

        case 12:
          _context2.next = 14;
          return value;

        case 14:
          _context2.next = 6;
          break;

        case 16:
          _context2.next = 21;
          break;

        case 18:
          _context2.prev = 18;
          _context2.t0 = _context2["catch"](4);

          _iterator.e(_context2.t0);

        case 21:
          _context2.prev = 21;

          _iterator.f();

          return _context2.finish(21);

        case 24:
        case "end":
          return _context2.stop();
      }
    }
  }, _marked2, null, [[4, 18, 21, 24]]);
}

exports.conditionStrategy = conditionStrategy;

function __bisect(source, at) {
  var strategy = typeof at === 'number' ? indexStrategy : conditionStrategy;
  return new Bisector(source, strategy, {
    at: at
  });
}

exports.__bisect = __bisect;
var bisect = /*#__PURE__*/iterableCurry(__bisect, {
  forceSync: true
});
exports.bisect = bisect;
},{"../$peekerate/peekerate.js":340,"../$to-array/to-array.js":399,"../../internal/bisector.js":485,"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],262:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$interleave/async-interleave.js'),
    __asyncInterleave = _require2.__asyncInterleave;

function asyncByComparison(_x, _x2) {
  return _asyncByComparison.apply(this, arguments);
}

function _asyncByComparison() {
  _asyncByComparison = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref, all) {
    var compare,
        candidate,
        _len,
        peekrs,
        _key,
        _iterator,
        _step,
        peekr,
        _args = arguments;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            compare = _ref.compare;

            for (_len = _args.length, peekrs = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
              peekrs[_key - 2] = _args[_key];
            }

          case 2:
            if (all.done) {
              _context.next = 12;
              break;
            }

            candidate = all.value;
            _iterator = _createForOfIteratorHelper(peekrs);

            try {
              for (_iterator.s(); !(_step = _iterator.n()).done;) {
                peekr = _step.value;

                if (!peekr.done && compare(peekr.value, candidate.value) < 0) {
                  candidate = peekr;
                }
              }
            } catch (err) {
              _iterator.e(err);
            } finally {
              _iterator.f();
            }

            _context.next = 8;
            return candidate.value;

          case 8:
            _context.next = 10;
            return _awaitAsyncGenerator(candidate.advance());

          case 10:
            _context.next = 2;
            break;

          case 12:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncByComparison.apply(this, arguments);
}

function __asyncCollate(sources, compare) {
  return __asyncInterleave(sources, asyncByComparison, {
    compare: compare
  });
}

exports.__asyncCollate = __asyncCollate;
var asyncCollate = /*#__PURE__*/asyncIterableCurry(__asyncCollate, {
  variadic: true
});
exports.asyncCollate = asyncCollate;
},{"../$interleave/async-interleave.js":321,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],263:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(byComparison);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$interleave/interleave.js'),
    __interleave = _require2.__interleave;

function byComparison(_ref, all) {
  var compare,
      candidate,
      _len,
      peekrs,
      _key,
      _iterator,
      _step,
      peekr,
      _args = arguments;

  return _regeneratorRuntime.wrap(function byComparison$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          compare = _ref.compare;

          for (_len = _args.length, peekrs = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
            peekrs[_key - 2] = _args[_key];
          }

        case 2:
          if (all.done) {
            _context.next = 11;
            break;
          }

          candidate = all.value;
          _iterator = _createForOfIteratorHelper(peekrs);

          try {
            for (_iterator.s(); !(_step = _iterator.n()).done;) {
              peekr = _step.value;

              if (!peekr.done && compare(peekr.value, candidate.value) < 0) {
                candidate = peekr;
              }
            }
          } catch (err) {
            _iterator.e(err);
          } finally {
            _iterator.f();
          }

          _context.next = 8;
          return candidate.value;

        case 8:
          candidate.advance();
          _context.next = 2;
          break;

        case 11:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

function __collate(sources, compare) {
  return __interleave(sources, byComparison, {
    compare: compare
  });
}

exports.__collate = __collate;
var collate = /*#__PURE__*/iterableCurry(__collate, {
  variadic: true
});
exports.collate = collate;
},{"../$interleave/interleave.js":322,"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],264:[function(require,module,exports){
var _slicedToArray = require("@babel/runtime/helpers/slicedToArray");

var _require = require('../../internal/async-iterable.js'),
    asyncEnsureIterable = _require.asyncEnsureIterable;

var _require2 = require('../../internal/curry.js'),
    curry = _require2.curry;

var _require3 = require('../$zip/async-zip.js'),
    __asyncZip = _require3.__asyncZip;

var _require4 = require('../$filter/async-filter.js'),
    __asyncFilter = _require4.__asyncFilter;

var _require5 = require('../$map/async-map.js'),
    __asyncMap = _require5.__asyncMap;

function __asyncCompress(source, included) {
  return __asyncMap(__asyncFilter(__asyncZip([source, included]), function (_ref) {
    var _ref2 = _slicedToArray(_ref, 2),
        isIncluded = _ref2[1];

    return isIncluded;
  }), function (_ref3) {
    var _ref4 = _slicedToArray(_ref3, 1),
        value = _ref4[0];

    return value;
  });
}

exports.__asyncCompress = __asyncCompress;
var asyncCompress = /*#__PURE__*/curry(function $compress(source, included) {
  return __asyncCompress(asyncEnsureIterable(source), asyncEnsureIterable(included));
});
exports.asyncCompress = asyncCompress;
},{"../$filter/async-filter.js":288,"../$map/async-map.js":337,"../$zip/async-zip.js":412,"../../internal/async-iterable.js":480,"../../internal/curry.js":488,"@babel/runtime/helpers/slicedToArray":59}],265:[function(require,module,exports){
var _slicedToArray = require("@babel/runtime/helpers/slicedToArray");

var _require = require('../../internal/iterable.js'),
    ensureIterable = _require.ensureIterable;

var _require2 = require('../../internal/curry.js'),
    curry = _require2.curry;

var _require3 = require('../$zip/zip.js'),
    __zip = _require3.__zip;

var _require4 = require('../$filter/filter.js'),
    __filter = _require4.__filter;

var _require5 = require('../$map/map.js'),
    __map = _require5.__map;

function __compress(source, included) {
  return __map(__filter(__zip([source, included]), function (_ref) {
    var _ref2 = _slicedToArray(_ref, 2),
        isIncluded = _ref2[1];

    return isIncluded;
  }), function (_ref3) {
    var _ref4 = _slicedToArray(_ref3, 1),
        value = _ref4[0];

    return value;
  });
}

exports.__compress = __compress;
var compress = /*#__PURE__*/curry(function $compress(source, included) {
  return __compress(ensureIterable(source), ensureIterable(included));
});
exports.compress = compress;
},{"../$filter/filter.js":289,"../$map/map.js":338,"../$zip/zip.js":413,"../../internal/curry.js":488,"../../internal/iterable.js":493,"@babel/runtime/helpers/slicedToArray":59}],266:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _asyncGeneratorDelegate = require("@babel/runtime/helpers/asyncGeneratorDelegate");

var _require = require('../../internal/async-iterable.js'),
    asyncWrapWithIterableIterator = _require.asyncWrapWithIterableIterator,
    asyncEnsureIterable = _require.asyncEnsureIterable;

function __asyncConcat() {
  return _asyncConcat.apply(this, arguments);
}

exports.__asyncConcat = __asyncConcat;

function _asyncConcat() {
  _asyncConcat = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
    var _len,
        sources,
        _key,
        _i,
        _sources,
        iterable,
        _args = arguments;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            for (_len = _args.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {
              sources[_key] = _args[_key];
            }

            _i = 0, _sources = sources;

          case 2:
            if (!(_i < _sources.length)) {
              _context.next = 8;
              break;
            }

            iterable = _sources[_i];
            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(asyncEnsureIterable(iterable)), _awaitAsyncGenerator), "t0", 5);

          case 5:
            _i++;
            _context.next = 2;
            break;

          case 8:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncConcat.apply(this, arguments);
}

var asyncConcat = /*#__PURE__*/asyncWrapWithIterableIterator(__asyncConcat);
exports.asyncConcat = asyncConcat;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncGeneratorDelegate":41,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],267:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__concat);

var _require = require('../../internal/iterable.js'),
    wrapWithIterableIterator = _require.wrapWithIterableIterator,
    ensureIterable = _require.ensureIterable;

function __concat() {
  var _len,
      sources,
      _key,
      _i,
      _sources,
      iterable,
      _args = arguments;

  return _regeneratorRuntime.wrap(function __concat$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          for (_len = _args.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {
            sources[_key] = _args[_key];
          }

          _i = 0, _sources = sources;

        case 2:
          if (!(_i < _sources.length)) {
            _context.next = 8;
            break;
          }

          iterable = _sources[_i];
          return _context.delegateYield(ensureIterable(iterable), "t0", 5);

        case 5:
          _i++;
          _context.next = 2;
          break;

        case 8:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

exports.__concat = __concat;
var concat = /*#__PURE__*/wrapWithIterableIterator(__concat);
exports.concat = concat;
},{"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],268:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

function __asyncConsume(_x) {
  return _asyncConsume.apply(this, arguments);
}

function _asyncConsume() {
  _asyncConsume = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable) {
    var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, _;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 2;
            _iterator = _asyncIterator(iterable);

          case 4:
            _context.next = 6;
            return _iterator.next();

          case 6:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 10;
            return _step.value;

          case 10:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 16;
              break;
            }

            _ = _value;

          case 13:
            _iteratorNormalCompletion = true;
            _context.next = 4;
            break;

          case 16:
            _context.next = 22;
            break;

          case 18:
            _context.prev = 18;
            _context.t0 = _context["catch"](2);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 22:
            _context.prev = 22;
            _context.prev = 23;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 27;
              break;
            }

            _context.next = 27;
            return _iterator["return"]();

          case 27:
            _context.prev = 27;

            if (!_didIteratorError) {
              _context.next = 30;
              break;
            }

            throw _iteratorError;

          case 30:
            return _context.finish(27);

          case 31:
            return _context.finish(22);

          case 32:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[2, 18, 22, 32], [23,, 27, 31]]);
  }));
  return _asyncConsume.apply(this, arguments);
}

exports.__asyncConsume = __asyncConsume;
var asyncConsume = /*#__PURE__*/asyncIterableCurry(__asyncConsume, {
  reduces: true
});
exports.asyncConsume = asyncConsume;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],269:[function(require,module,exports){
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

function __consume(iterable) {
  var _iterator = _createForOfIteratorHelper(iterable),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var _ = _step.value;
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }
}

exports.__consume = __consume;
var consume = /*#__PURE__*/iterableCurry(__consume, {
  reduces: true
});
exports.consume = consume;
},{"../../internal/iterable.js":493}],270:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _asyncGeneratorDelegate = require("@babel/runtime/helpers/asyncGeneratorDelegate");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$to-array/async-to-array.js'),
    __asyncToArray = _require2.__asyncToArray;

var _require3 = require('./cycle-times.js'),
    __cycleTimes = _require3.__cycleTimes;

function __asyncCycleTimes(_x, _x2) {
  return _asyncCycleTimes.apply(this, arguments);
}

exports.__asyncCycleTimes = __asyncCycleTimes;

function _asyncCycleTimes() {
  _asyncCycleTimes = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, n) {
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.t0 = _asyncGeneratorDelegate;
            _context.t1 = _asyncIterator;
            _context.t2 = __cycleTimes;
            _context.next = 5;
            return _awaitAsyncGenerator(__asyncToArray(source));

          case 5:
            _context.t3 = _context.sent;
            _context.t4 = n;
            _context.t5 = (0, _context.t2)(_context.t3, _context.t4);
            _context.t6 = (0, _context.t1)(_context.t5);
            _context.t7 = _awaitAsyncGenerator;
            return _context.delegateYield((0, _context.t0)(_context.t6, _context.t7), "t8", 11);

          case 11:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncCycleTimes.apply(this, arguments);
}

var asyncCycleTimes = /*#__PURE__*/asyncIterableCurry(__asyncCycleTimes);
exports.asyncCycleTimes = asyncCycleTimes;
},{"../$to-array/async-to-array.js":398,"../../internal/async-iterable.js":480,"./cycle-times.js":271,"@babel/runtime/helpers/asyncGeneratorDelegate":41,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],271:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__cycleTimes);

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$to-array/to-array.js'),
    __toArray = _require2.__toArray;

function __cycleTimes(source, n) {
  var arr;
  return _regeneratorRuntime.wrap(function __cycleTimes$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          arr = Array.isArray(source) ? source : __toArray(source);

          if (arr.length) {
            _context.next = 3;
            break;
          }

          return _context.abrupt("return");

        case 3:
          if (!n--) {
            _context.next = 7;
            break;
          }

          return _context.delegateYield(arr, "t0", 5);

        case 5:
          _context.next = 3;
          break;

        case 7:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

exports.__cycleTimes = __cycleTimes;
var cycleTimes = /*#__PURE__*/iterableCurry(__cycleTimes);
exports.cycleTimes = cycleTimes;
},{"../$to-array/to-array.js":399,"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],272:[function(require,module,exports){
var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$cycle-times/async-cycle-times.js'),
    __asyncCycleTimes = _require2.__asyncCycleTimes;

function __asyncCycle(source) {
  return __asyncCycleTimes(source, Infinity);
}

exports.__asyncCycle = __asyncCycle;
var asyncCycle = /*#__PURE__*/asyncIterableCurry(__asyncCycle);
exports.asyncCycle = asyncCycle;
},{"../$cycle-times/async-cycle-times.js":270,"../../internal/async-iterable.js":480}],273:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$cycle-times/cycle-times.js'),
    __cycleTimes = _require2.__cycleTimes;

function __cycle(source) {
  return __cycleTimes(source, Infinity);
}

exports.__cycle = __cycle;
var cycle = /*#__PURE__*/iterableCurry(__cycle);
exports.cycle = cycle;
},{"../$cycle-times/cycle-times.js":271,"../../internal/iterable.js":493}],274:[function(require,module,exports){
var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _regeneratorRuntime = require("@babel/runtime/regenerator");

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIsIterable = _require.asyncIsIterable,
    asyncIsWrappable = _require.asyncIsWrappable;

var _require2 = require('../$map/map.js'),
    __map = _require2.__map;

var _require3 = require('../$every/every.js'),
    __every = _require3.__every;

var _require4 = require('../$zip-all/async-zip-all.js'),
    __asyncZipAll = _require4.__asyncZipAll;

var _require5 = require('../$slice/slice.js'),
    __sliceFromStart = _require5.__sliceFromStart;

var none = Symbol('none');
var zipAllConfig = {
  filler: none
};

var asyncEmpty = /*#__PURE__*/function () {
  var _ref = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));

  return function asyncEmpty() {
    return _ref.apply(this, arguments);
  };
}();

var asyncIterableOrEmpty = function asyncIterableOrEmpty(value) {
  return value == null ? asyncEmpty() : value;
};

function _asyncDeepEqual(_x, _x2, _x3) {
  return _asyncDeepEqual2.apply(this, arguments);
}

function _asyncDeepEqual2() {
  _asyncDeepEqual2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(values, same, isIterable) {
    var depth,
        _iteratorNormalCompletion,
        _didIteratorError,
        _iteratorError,
        _iterator,
        _step,
        _value,
        stepValues,
        firstValue,
        _iterator2,
        _step2,
        value,
        _args2 = arguments;

    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            depth = _args2.length > 3 && _args2[3] !== undefined ? _args2[3] : 0;

            if (!__every(values, function (value) {
              return typeof value !== 'string' && isIterable(value);
            })) {
              _context2.next = 40;
              break;
            }

            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context2.prev = 4;
            _iterator = _asyncIterator(__asyncZipAll(__map(values, asyncIterableOrEmpty), zipAllConfig));

          case 6:
            _context2.next = 8;
            return _iterator.next();

          case 8:
            _step = _context2.sent;
            _iteratorNormalCompletion = _step.done;
            _context2.next = 12;
            return _step.value;

          case 12:
            _value = _context2.sent;

            if (_iteratorNormalCompletion) {
              _context2.next = 22;
              break;
            }

            stepValues = _value;
            _context2.next = 17;
            return _asyncDeepEqual(stepValues, same, isIterable, depth + 1);

          case 17:
            if (_context2.sent) {
              _context2.next = 19;
              break;
            }

            return _context2.abrupt("return", false);

          case 19:
            _iteratorNormalCompletion = true;
            _context2.next = 6;
            break;

          case 22:
            _context2.next = 28;
            break;

          case 24:
            _context2.prev = 24;
            _context2.t0 = _context2["catch"](4);
            _didIteratorError = true;
            _iteratorError = _context2.t0;

          case 28:
            _context2.prev = 28;
            _context2.prev = 29;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context2.next = 33;
              break;
            }

            _context2.next = 33;
            return _iterator["return"]();

          case 33:
            _context2.prev = 33;

            if (!_didIteratorError) {
              _context2.next = 36;
              break;
            }

            throw _iteratorError;

          case 36:
            return _context2.finish(33);

          case 37:
            return _context2.finish(28);

          case 38:
            _context2.next = 58;
            break;

          case 40:
            firstValue = values[0];
            _iterator2 = _createForOfIteratorHelper(__sliceFromStart(values, 1));
            _context2.prev = 42;

            _iterator2.s();

          case 44:
            if ((_step2 = _iterator2.n()).done) {
              _context2.next = 50;
              break;
            }

            value = _step2.value;

            if (same(value, firstValue, depth)) {
              _context2.next = 48;
              break;
            }

            return _context2.abrupt("return", false);

          case 48:
            _context2.next = 44;
            break;

          case 50:
            _context2.next = 55;
            break;

          case 52:
            _context2.prev = 52;
            _context2.t1 = _context2["catch"](42);

            _iterator2.e(_context2.t1);

          case 55:
            _context2.prev = 55;

            _iterator2.f();

            return _context2.finish(55);

          case 58:
            return _context2.abrupt("return", true);

          case 59:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2, null, [[4, 24, 28, 38], [29,, 33, 37], [42, 52, 55, 58]]);
  }));
  return _asyncDeepEqual2.apply(this, arguments);
}

exports._asyncDeepEqual = _asyncDeepEqual;

function __asyncDeepEqual(values) {
  var same = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Object.is;
  var coerceNil = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
  return values.length <= 1 ? true : _asyncDeepEqual(values, same, coerceNil ? asyncIsWrappable : asyncIsIterable);
}

exports.__asyncDeepEqual = __asyncDeepEqual;

function asyncDeepEqual() {
  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
    values[_key] = arguments[_key];
  }

  return __asyncDeepEqual(values);
}

exports.asyncDeepEqual = asyncDeepEqual;
},{"../$every/every.js":287,"../$map/map.js":338,"../$slice/slice.js":354,"../$zip-all/async-zip-all.js":410,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],275:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    isIterable = _require.isIterable,
    isWrappable = _require.isWrappable;

var _require2 = require('../$map/map.js'),
    __map = _require2.__map;

var _require3 = require('../$every/every.js'),
    __every = _require3.__every;

var _require4 = require('../$zip-all/zip-all.js'),
    __zipAll = _require4.__zipAll;

var _require5 = require('../$slice/slice.js'),
    __sliceFromStart = _require5.__sliceFromStart;

var none = Symbol('none');
var zipAllConfig = {
  filler: none
};

var empty = /*#__PURE__*/_regeneratorRuntime.mark(function empty() {
  return _regeneratorRuntime.wrap(function empty$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
        case "end":
          return _context.stop();
      }
    }
  }, empty);
});

var iterableOrEmpty = function iterableOrEmpty(value) {
  return value == null ? empty() : value;
};

function _deepEqual(values, same, isIterable) {
  var depth = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;

  if (__every(values, function (value) {
    return typeof value !== 'string' && isIterable(value);
  })) {
    var _iterator = _createForOfIteratorHelper(__zipAll(__map(values, iterableOrEmpty), zipAllConfig)),
        _step;

    try {
      for (_iterator.s(); !(_step = _iterator.n()).done;) {
        var stepValues = _step.value;
        if (!_deepEqual(stepValues, same, isIterable, depth + 1)) return false;
      }
    } catch (err) {
      _iterator.e(err);
    } finally {
      _iterator.f();
    }
  } else {
    var firstValue = values[0];

    var _iterator2 = _createForOfIteratorHelper(__sliceFromStart(values, 1)),
        _step2;

    try {
      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
        var value = _step2.value;
        if (!same(value, firstValue, depth)) return false;
      }
    } catch (err) {
      _iterator2.e(err);
    } finally {
      _iterator2.f();
    }
  }

  return true;
}

exports._deepEqual = _deepEqual;

function __deepEqual(values) {
  var same = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Object.is;
  var coerceNil = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
  return values.length <= 1 ? true : _deepEqual(values, same, coerceNil ? isWrappable : isIterable);
}

exports.__deepEqual = __deepEqual;

function deepEqual() {
  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
    values[_key] = arguments[_key];
  }

  return __deepEqual(values);
}

exports.deepEqual = deepEqual;
},{"../$every/every.js":287,"../$map/map.js":338,"../$slice/slice.js":354,"../$zip-all/zip-all.js":411,"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],276:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

function __asyncDistinct(_x, _x2) {
  return _asyncDistinct.apply(this, arguments);
}

exports.__asyncDistinct = __asyncDistinct;

function _asyncDistinct() {
  _asyncDistinct = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, selector) {
    var set, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value, key;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            set = new Set();
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 3;
            _iterator = _asyncIterator(source);

          case 5:
            _context.next = 7;
            return _awaitAsyncGenerator(_iterator.next());

          case 7:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 11;
            return _awaitAsyncGenerator(_step.value);

          case 11:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 23;
              break;
            }

            value = _value;
            key = selector ? selector(value) : value;

            if (!set.has(key)) {
              _context.next = 17;
              break;
            }

            return _context.abrupt("continue", 20);

          case 17:
            set.add(key);
            _context.next = 20;
            return value;

          case 20:
            _iteratorNormalCompletion = true;
            _context.next = 5;
            break;

          case 23:
            _context.next = 29;
            break;

          case 25:
            _context.prev = 25;
            _context.t0 = _context["catch"](3);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 29:
            _context.prev = 29;
            _context.prev = 30;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 34;
              break;
            }

            _context.next = 34;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 34:
            _context.prev = 34;

            if (!_didIteratorError) {
              _context.next = 37;
              break;
            }

            throw _iteratorError;

          case 37:
            return _context.finish(34);

          case 38:
            return _context.finish(29);

          case 39:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[3, 25, 29, 39], [30,, 34, 38]]);
  }));
  return _asyncDistinct.apply(this, arguments);
}

var asyncDistinct = asyncIterableCurry(__asyncDistinct, {
  minArgs: 0,
  maxArgs: 1
});
exports.asyncDistinct = asyncDistinct;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],277:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__distinct);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

function __distinct(source, selector) {
  var set, _iterator, _step, value, key;

  return _regeneratorRuntime.wrap(function __distinct$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          set = new Set();
          _iterator = _createForOfIteratorHelper(source);
          _context.prev = 2;

          _iterator.s();

        case 4:
          if ((_step = _iterator.n()).done) {
            _context.next = 14;
            break;
          }

          value = _step.value;
          key = selector ? selector(value) : value;

          if (!set.has(key)) {
            _context.next = 9;
            break;
          }

          return _context.abrupt("continue", 12);

        case 9:
          set.add(key);
          _context.next = 12;
          return value;

        case 12:
          _context.next = 4;
          break;

        case 14:
          _context.next = 19;
          break;

        case 16:
          _context.prev = 16;
          _context.t0 = _context["catch"](2);

          _iterator.e(_context.t0);

        case 19:
          _context.prev = 19;

          _iterator.f();

          return _context.finish(19);

        case 22:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[2, 16, 19, 22]]);
}

exports.__distinct = __distinct;
var distinct = iterableCurry(__distinct, {
  minArgs: 0,
  maxArgs: 1
});
exports.distinct = distinct;
},{"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],278:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

function __asyncDropWhile(_x, _x2) {
  return _asyncDropWhile.apply(this, arguments);
}

exports.__asyncDropWhile = __asyncDropWhile;

function _asyncDropWhile() {
  _asyncDropWhile = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, predicate) {
    var drop, c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            drop = true;
            c = 0;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 4;
            _iterator = _asyncIterator(source);

          case 6:
            _context.next = 8;
            return _awaitAsyncGenerator(_iterator.next());

          case 8:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 12;
            return _awaitAsyncGenerator(_step.value);

          case 12:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 29;
              break;
            }

            value = _value;

            if (drop) {
              _context.next = 20;
              break;
            }

            _context.next = 18;
            return value;

          case 18:
            _context.next = 26;
            break;

          case 20:
            _context.next = 22;
            return _awaitAsyncGenerator(predicate(value, c++));

          case 22:
            drop = _context.sent;

            if (drop) {
              _context.next = 26;
              break;
            }

            _context.next = 26;
            return value;

          case 26:
            _iteratorNormalCompletion = true;
            _context.next = 6;
            break;

          case 29:
            _context.next = 35;
            break;

          case 31:
            _context.prev = 31;
            _context.t0 = _context["catch"](4);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 35:
            _context.prev = 35;
            _context.prev = 36;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 40;
              break;
            }

            _context.next = 40;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 40:
            _context.prev = 40;

            if (!_didIteratorError) {
              _context.next = 43;
              break;
            }

            throw _iteratorError;

          case 43:
            return _context.finish(40);

          case 44:
            return _context.finish(35);

          case 45:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[4, 31, 35, 45], [36,, 40, 44]]);
  }));
  return _asyncDropWhile.apply(this, arguments);
}

var asyncDropWhile = /*#__PURE__*/asyncIterableCurry(__asyncDropWhile);
exports.asyncDropWhile = asyncDropWhile;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],279:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__dropWhile);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

function __dropWhile(source, predicate) {
  var drop, c, _iterator, _step, value;

  return _regeneratorRuntime.wrap(function __dropWhile$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          drop = true;
          c = 0;
          _iterator = _createForOfIteratorHelper(source);
          _context.prev = 3;

          _iterator.s();

        case 5:
          if ((_step = _iterator.n()).done) {
            _context.next = 18;
            break;
          }

          value = _step.value;

          if (drop) {
            _context.next = 12;
            break;
          }

          _context.next = 10;
          return value;

        case 10:
          _context.next = 16;
          break;

        case 12:
          drop = predicate(value, c++);

          if (drop) {
            _context.next = 16;
            break;
          }

          _context.next = 16;
          return value;

        case 16:
          _context.next = 5;
          break;

        case 18:
          _context.next = 23;
          break;

        case 20:
          _context.prev = 20;
          _context.t0 = _context["catch"](3);

          _iterator.e(_context.t0);

        case 23:
          _context.prev = 23;

          _iterator.f();

          return _context.finish(23);

        case 26:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[3, 20, 23, 26]]);
}

exports.__dropWhile = __dropWhile;
var dropWhile = /*#__PURE__*/iterableCurry(__dropWhile);
exports.dropWhile = dropWhile;
},{"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],280:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

function __asyncDrop(_x, _x2) {
  return _asyncDrop.apply(this, arguments);
}

exports.__asyncDrop = __asyncDrop;

function _asyncDrop() {
  _asyncDrop = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, n) {
    var i, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            i = 0;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 3;
            _iterator = _asyncIterator(iterable);

          case 5:
            _context.next = 7;
            return _awaitAsyncGenerator(_iterator.next());

          case 7:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 11;
            return _awaitAsyncGenerator(_step.value);

          case 11:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 20;
              break;
            }

            value = _value;

            if (!(i++ >= n)) {
              _context.next = 17;
              break;
            }

            _context.next = 17;
            return value;

          case 17:
            _iteratorNormalCompletion = true;
            _context.next = 5;
            break;

          case 20:
            _context.next = 26;
            break;

          case 22:
            _context.prev = 22;
            _context.t0 = _context["catch"](3);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 26:
            _context.prev = 26;
            _context.prev = 27;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 31;
              break;
            }

            _context.next = 31;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 31:
            _context.prev = 31;

            if (!_didIteratorError) {
              _context.next = 34;
              break;
            }

            throw _iteratorError;

          case 34:
            return _context.finish(31);

          case 35:
            return _context.finish(26);

          case 36:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[3, 22, 26, 36], [27,, 31, 35]]);
  }));
  return _asyncDrop.apply(this, arguments);
}

var asyncDrop = /*#__PURE__*/asyncIterableCurry(__asyncDrop);
exports.asyncDrop = asyncDrop;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],281:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__drop);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

function __drop(iterable, n) {
  var i, _iterator, _step, value;

  return _regeneratorRuntime.wrap(function __drop$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          i = 0;
          _iterator = _createForOfIteratorHelper(iterable);
          _context.prev = 2;

          _iterator.s();

        case 4:
          if ((_step = _iterator.n()).done) {
            _context.next = 11;
            break;
          }

          value = _step.value;

          if (!(i++ >= n)) {
            _context.next = 9;
            break;
          }

          _context.next = 9;
          return value;

        case 9:
          _context.next = 4;
          break;

        case 11:
          _context.next = 16;
          break;

        case 13:
          _context.prev = 13;
          _context.t0 = _context["catch"](2);

          _iterator.e(_context.t0);

        case 16:
          _context.prev = 16;

          _iterator.f();

          return _context.finish(16);

        case 19:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[2, 13, 16, 19]]);
}

exports.__drop = __drop;
var drop = /*#__PURE__*/iterableCurry(__drop);
exports.drop = drop;
},{"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],282:[function(require,module,exports){
var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$map/async-map.js'),
    __asyncMap = _require2.__asyncMap;

function __asyncEnumerate(source) {
  var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
  return __asyncMap(source, function (value, i) {
    return [start + i, value];
  });
}

exports.__asyncEnumerate = __asyncEnumerate;
var asyncEnumerate = /*#__PURE__*/asyncIterableCurry(__asyncEnumerate, {
  minArgs: 0,
  maxArgs: 1
});
exports.asyncEnumerate = asyncEnumerate;
},{"../$map/async-map.js":337,"../../internal/async-iterable.js":480}],283:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$map/map.js'),
    __map = _require2.__map;

function __enumerate(source) {
  var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
  return __map(source, function (value, i) {
    return [start + i, value];
  });
}

exports.__enumerate = __enumerate;
var enumerate = /*#__PURE__*/iterableCurry(__enumerate, {
  minArgs: 0,
  maxArgs: 1
});
exports.enumerate = enumerate;
},{"../$map/map.js":338,"../../internal/iterable.js":493}],284:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$zip-all/async-zip-all.js'),
    __asyncZipAll = _require2.__asyncZipAll;

var _require3 = require('../$slice/slice.js'),
    __sliceFromStart = _require3.__sliceFromStart;

var none = Symbol('none');
var zipAllConfig = {
  filler: none
};

function __asyncEqual(_x) {
  return _asyncEqual.apply(this, arguments);
}

function _asyncEqual() {
  _asyncEqual = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterables) {
    var same,
        _iteratorNormalCompletion,
        _didIteratorError,
        _iteratorError,
        _iterator,
        _step,
        _value,
        stepValues,
        firstValue,
        _iterator2,
        _step2,
        value,
        _args = arguments;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            same = _args.length > 1 && _args[1] !== undefined ? _args[1] : Object.is;

            if (!(iterables.length <= 1)) {
              _context.next = 3;
              break;
            }

            return _context.abrupt("return", true);

          case 3:
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 5;
            _iterator = _asyncIterator(__asyncZipAll(iterables, zipAllConfig));

          case 7:
            _context.next = 9;
            return _iterator.next();

          case 9:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 13;
            return _step.value;

          case 13:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 37;
              break;
            }

            stepValues = _value;
            firstValue = stepValues[0];
            _iterator2 = _createForOfIteratorHelper(__sliceFromStart(stepValues, 1));
            _context.prev = 18;

            _iterator2.s();

          case 20:
            if ((_step2 = _iterator2.n()).done) {
              _context.next = 26;
              break;
            }

            value = _step2.value;

            if (same(value, firstValue)) {
              _context.next = 24;
              break;
            }

            return _context.abrupt("return", false);

          case 24:
            _context.next = 20;
            break;

          case 26:
            _context.next = 31;
            break;

          case 28:
            _context.prev = 28;
            _context.t0 = _context["catch"](18);

            _iterator2.e(_context.t0);

          case 31:
            _context.prev = 31;

            _iterator2.f();

            return _context.finish(31);

          case 34:
            _iteratorNormalCompletion = true;
            _context.next = 7;
            break;

          case 37:
            _context.next = 43;
            break;

          case 39:
            _context.prev = 39;
            _context.t1 = _context["catch"](5);
            _didIteratorError = true;
            _iteratorError = _context.t1;

          case 43:
            _context.prev = 43;
            _context.prev = 44;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 48;
              break;
            }

            _context.next = 48;
            return _iterator["return"]();

          case 48:
            _context.prev = 48;

            if (!_didIteratorError) {
              _context.next = 51;
              break;
            }

            throw _iteratorError;

          case 51:
            return _context.finish(48);

          case 52:
            return _context.finish(43);

          case 53:
            return _context.abrupt("return", true);

          case 54:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[5, 39, 43, 53], [18, 28, 31, 34], [44,, 48, 52]]);
  }));
  return _asyncEqual.apply(this, arguments);
}

exports.__asyncEqual = __asyncEqual;
var asyncEqual = /*#__PURE__*/asyncIterableCurry(__asyncEqual, {
  minArgs: 0,
  maxArgs: 1,
  variadic: true,
  reduces: true
});
exports.asyncEqual = asyncEqual;
},{"../$slice/slice.js":354,"../$zip-all/async-zip-all.js":410,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],285:[function(require,module,exports){
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$zip-all/zip-all.js'),
    __zipAll = _require2.__zipAll;

var _require3 = require('../$slice/slice.js'),
    __sliceFromStart = _require3.__sliceFromStart;

var none = Symbol('none');
var zipAllConfig = {
  filler: none
};

function __equal(iterables) {
  var same = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Object.is;
  if (iterables.length <= 1) return true;

  var _iterator = _createForOfIteratorHelper(__zipAll(iterables, zipAllConfig)),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var stepValues = _step.value;
      var firstValue = stepValues[0];

      var _iterator2 = _createForOfIteratorHelper(__sliceFromStart(stepValues, 1)),
          _step2;

      try {
        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
          var value = _step2.value;
          if (!same(value, firstValue)) return false;
        }
      } catch (err) {
        _iterator2.e(err);
      } finally {
        _iterator2.f();
      }
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

  return true;
}

exports.__equal = __equal;
var equal = /*#__PURE__*/iterableCurry(__equal, {
  minArgs: 0,
  maxArgs: 1,
  variadic: true,
  reduces: true
});
exports.equal = equal;
},{"../$slice/slice.js":354,"../$zip-all/zip-all.js":411,"../../internal/iterable.js":493}],286:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

function __asyncEvery(_x, _x2) {
  return _asyncEvery.apply(this, arguments);
}

function _asyncEvery() {
  _asyncEvery = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, predicate) {
    var c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            c = 0;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 3;
            _iterator = _asyncIterator(iterable);

          case 5:
            _context.next = 7;
            return _iterator.next();

          case 7:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 11;
            return _step.value;

          case 11:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 21;
              break;
            }

            value = _value;
            _context.next = 16;
            return predicate(value, c++);

          case 16:
            if (_context.sent) {
              _context.next = 18;
              break;
            }

            return _context.abrupt("return", false);

          case 18:
            _iteratorNormalCompletion = true;
            _context.next = 5;
            break;

          case 21:
            _context.next = 27;
            break;

          case 23:
            _context.prev = 23;
            _context.t0 = _context["catch"](3);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 27:
            _context.prev = 27;
            _context.prev = 28;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 32;
              break;
            }

            _context.next = 32;
            return _iterator["return"]();

          case 32:
            _context.prev = 32;

            if (!_didIteratorError) {
              _context.next = 35;
              break;
            }

            throw _iteratorError;

          case 35:
            return _context.finish(32);

          case 36:
            return _context.finish(27);

          case 37:
            return _context.abrupt("return", true);

          case 38:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[3, 23, 27, 37], [28,, 32, 36]]);
  }));
  return _asyncEvery.apply(this, arguments);
}

exports.__asyncEvery = __asyncEvery;
var asyncEvery = /*#__PURE__*/asyncIterableCurry(__asyncEvery, {
  reduces: true
});
exports.asyncEvery = asyncEvery;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],287:[function(require,module,exports){
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

function __every(iterable, predicate) {
  var c = 0;

  var _iterator = _createForOfIteratorHelper(iterable),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var value = _step.value;

      if (!predicate(value, c++)) {
        return false;
      }
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

  return true;
}

exports.__every = __every;
var every = /*#__PURE__*/iterableCurry(__every, {
  reduces: true
});
exports.every = every;
},{"../../internal/iterable.js":493}],288:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

function __asyncFilter(_x, _x2) {
  return _asyncFilter.apply(this, arguments);
}

exports.__asyncFilter = __asyncFilter;

function _asyncFilter() {
  _asyncFilter = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, predicate) {
    var c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            c = 0;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 3;
            _iterator = _asyncIterator(source);

          case 5:
            _context.next = 7;
            return _awaitAsyncGenerator(_iterator.next());

          case 7:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 11;
            return _awaitAsyncGenerator(_step.value);

          case 11:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 22;
              break;
            }

            value = _value;
            _context.next = 16;
            return _awaitAsyncGenerator(predicate(value, c++));

          case 16:
            if (!_context.sent) {
              _context.next = 19;
              break;
            }

            _context.next = 19;
            return value;

          case 19:
            _iteratorNormalCompletion = true;
            _context.next = 5;
            break;

          case 22:
            _context.next = 28;
            break;

          case 24:
            _context.prev = 24;
            _context.t0 = _context["catch"](3);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 28:
            _context.prev = 28;
            _context.prev = 29;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 33;
              break;
            }

            _context.next = 33;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 33:
            _context.prev = 33;

            if (!_didIteratorError) {
              _context.next = 36;
              break;
            }

            throw _iteratorError;

          case 36:
            return _context.finish(33);

          case 37:
            return _context.finish(28);

          case 38:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[3, 24, 28, 38], [29,, 33, 37]]);
  }));
  return _asyncFilter.apply(this, arguments);
}

var asyncFilter = /*#__PURE__*/asyncIterableCurry(__asyncFilter);
exports.asyncFilter = asyncFilter;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],289:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__filter);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

function __filter(source, predicate) {
  var c, _iterator, _step, value;

  return _regeneratorRuntime.wrap(function __filter$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          c = 0;
          _iterator = _createForOfIteratorHelper(source);
          _context.prev = 2;

          _iterator.s();

        case 4:
          if ((_step = _iterator.n()).done) {
            _context.next = 11;
            break;
          }

          value = _step.value;

          if (!predicate(value, c++)) {
            _context.next = 9;
            break;
          }

          _context.next = 9;
          return value;

        case 9:
          _context.next = 4;
          break;

        case 11:
          _context.next = 16;
          break;

        case 13:
          _context.prev = 13;
          _context.t0 = _context["catch"](2);

          _iterator.e(_context.t0);

        case 16:
          _context.prev = 16;

          _iterator.f();

          return _context.finish(16);

        case 19:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[2, 13, 16, 19]]);
}

exports.__filter = __filter;
var filter = /*#__PURE__*/iterableCurry(__filter);
exports.filter = filter;
},{"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],290:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$peekerate/async-peekerate.js'),
    __asyncPeekerate = _require2.__asyncPeekerate;

function __asyncFindBestOr(_x, _x2, _x3) {
  return _asyncFindBestOr.apply(this, arguments);
}

function _asyncFindBestOr() {
  _asyncFindBestOr = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, notFoundValue, comparer) {
    var mapper,
        peekr,
        best,
        bestValue,
        candidate,
        candidateValue,
        _args = arguments;
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            mapper = _args.length > 3 && _args[3] !== undefined ? _args[3] : function (value) {
              return value;
            };
            _context.next = 3;
            return __asyncPeekerate(iterable);

          case 3:
            peekr = _context.sent;

            if (!peekr.done) {
              _context.next = 8;
              break;
            }

            return _context.abrupt("return", notFoundValue);

          case 8:
            best = peekr.value;
            _context.next = 11;
            return mapper(best, peekr.index);

          case 11:
            bestValue = _context.sent;
            _context.next = 14;
            return peekr.advance();

          case 14:
            if (peekr.done) {
              _context.next = 24;
              break;
            }

            candidate = peekr.value;
            _context.next = 18;
            return mapper(candidate, peekr.index);

          case 18:
            candidateValue = _context.sent;

            if (comparer(bestValue, candidateValue)) {
              best = candidate;
              bestValue = candidateValue;
            }

            _context.next = 22;
            return peekr.advance();

          case 22:
            _context.next = 14;
            break;

          case 24:
            return _context.abrupt("return", best);

          case 25:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncFindBestOr.apply(this, arguments);
}

exports.__asyncFindBestOr = __asyncFindBestOr;
var asyncFindBestOr = asyncIterableCurry(__asyncFindBestOr, {
  reduces: true,
  minArgs: 2,
  maxArgs: 3,
  growRight: true
});
exports.asyncFindBestOr = asyncFindBestOr;
},{"../$peekerate/async-peekerate.js":339,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],291:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$peekerate/peekerate.js'),
    __peekerate = _require2.__peekerate;

function __findBestOr(iterable, notFoundValue, comparer) {
  var mapper = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : function (value) {
    return value;
  };

  var peekr = __peekerate(iterable);

  if (peekr.done) {
    return notFoundValue;
  } else {
    var best = peekr.value;
    var bestValue = mapper(best, peekr.index);
    peekr.advance();

    while (!peekr.done) {
      var candidate = peekr.value;
      var candidateValue = mapper(candidate, peekr.index);

      if (comparer(bestValue, candidateValue)) {
        best = candidate;
        bestValue = candidateValue;
      }

      peekr.advance();
    }

    return best;
  }
}

exports.__findBestOr = __findBestOr;
var findBestOr = iterableCurry(__findBestOr, {
  reduces: true,
  minArgs: 2,
  maxArgs: 3,
  growRight: true
});
exports.findBestOr = findBestOr;
},{"../$peekerate/peekerate.js":340,"../../internal/iterable.js":493}],292:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$find-best-or/async-find-best-or.js'),
    __asyncFindBestOr = _require2.__asyncFindBestOr;

function __asyncFindBest(_x, _x2) {
  return _asyncFindBest.apply(this, arguments);
}

function _asyncFindBest() {
  _asyncFindBest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, comparer) {
    var mapper,
        _args = arguments;
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            mapper = _args.length > 2 && _args[2] !== undefined ? _args[2] : function (value) {
              return value;
            };
            _context.next = 3;
            return __asyncFindBestOr(iterable, undefined, comparer, mapper);

          case 3:
            return _context.abrupt("return", _context.sent);

          case 4:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncFindBest.apply(this, arguments);
}

exports.__asyncFindBest = __asyncFindBest;
var asyncFindBest = asyncIterableCurry(__asyncFindBest, {
  reduces: true,
  minArgs: 1,
  maxArgs: 2,
  growRight: true
});
exports.asyncFindBest = asyncFindBest;
},{"../$find-best-or/async-find-best-or.js":290,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],293:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$find-best-or/find-best-or.js'),
    __findBestOr = _require2.__findBestOr;

function __findBest(iterable, comparer) {
  var mapper = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function (value) {
    return value;
  };
  return __findBestOr(iterable, undefined, comparer, mapper);
}

exports.__findBest = __findBest;
var findBest = iterableCurry(__findBest, {
  reduces: true,
  minArgs: 1,
  maxArgs: 2,
  growRight: true
});
exports.findBest = findBest;
},{"../$find-best-or/find-best-or.js":291,"../../internal/iterable.js":493}],294:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

function __asyncFindOr(_x, _x2, _x3) {
  return _asyncFindOr.apply(this, arguments);
}

function _asyncFindOr() {
  _asyncFindOr = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, notFoundValue, func) {
    var c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            c = 0;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 3;
            _iterator = _asyncIterator(iterable);

          case 5:
            _context.next = 7;
            return _iterator.next();

          case 7:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 11;
            return _step.value;

          case 11:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 21;
              break;
            }

            value = _value;
            _context.next = 16;
            return func(value, c++);

          case 16:
            if (!_context.sent) {
              _context.next = 18;
              break;
            }

            return _context.abrupt("return", value);

          case 18:
            _iteratorNormalCompletion = true;
            _context.next = 5;
            break;

          case 21:
            _context.next = 27;
            break;

          case 23:
            _context.prev = 23;
            _context.t0 = _context["catch"](3);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 27:
            _context.prev = 27;
            _context.prev = 28;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 32;
              break;
            }

            _context.next = 32;
            return _iterator["return"]();

          case 32:
            _context.prev = 32;

            if (!_didIteratorError) {
              _context.next = 35;
              break;
            }

            throw _iteratorError;

          case 35:
            return _context.finish(32);

          case 36:
            return _context.finish(27);

          case 37:
            return _context.abrupt("return", notFoundValue);

          case 38:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[3, 23, 27, 37], [28,, 32, 36]]);
  }));
  return _asyncFindOr.apply(this, arguments);
}

exports.__asyncFindOr = __asyncFindOr;
var asyncFindOr = /*#__PURE__*/asyncIterableCurry(__asyncFindOr, {
  growRight: true,
  reduces: true
});
exports.asyncFindOr = asyncFindOr;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],295:[function(require,module,exports){
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

function __findOr(iterable, notFoundValue, func) {
  var c = 0;

  var _iterator = _createForOfIteratorHelper(iterable),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var value = _step.value;

      if (func(value, c++)) {
        return value;
      }
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

  return notFoundValue;
}

exports.__findOr = __findOr;
var findOr = /*#__PURE__*/iterableCurry(__findOr, {
  growRight: true,
  reduces: true
});
exports.findOr = findOr;
},{"../../internal/iterable.js":493}],296:[function(require,module,exports){
var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$find-or/async-find-or.js'),
    __asyncFindOr = _require2.__asyncFindOr;

function __asyncFind(iterable, predicate) {
  return __asyncFindOr(iterable, undefined, predicate);
}

exports.__asyncFind = __asyncFind;
var asyncFind = /*#__PURE__*/asyncIterableCurry(__asyncFind, {
  reduces: true
});
exports.asyncFind = asyncFind;
},{"../$find-or/async-find-or.js":294,"../../internal/async-iterable.js":480}],297:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$find-or/find-or.js'),
    __findOr = _require2.__findOr;

function __find(iterable, predicate) {
  return __findOr(iterable, undefined, predicate);
}

exports.__find = __find;
var find = /*#__PURE__*/iterableCurry(__find, {
  reduces: true
});
exports.find = find;
},{"../$find-or/find-or.js":295,"../../internal/iterable.js":493}],298:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry,
    asyncCallReturn = _require.asyncCallReturn;

function __asyncFirstOr(_x, _x2) {
  return _asyncFirstOr.apply(this, arguments);
}

function _asyncFirstOr() {
  _asyncFirstOr = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, whenEmpty) {
    var iter, _yield$iter$next, value, done;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            iter = iterable[Symbol.asyncIterator]();
            _context.next = 3;
            return iter.next();

          case 3:
            _yield$iter$next = _context.sent;
            value = _yield$iter$next.value;
            done = _yield$iter$next.done;

            if (!done) {
              _context.next = 8;
              break;
            }

            return _context.abrupt("return", whenEmpty);

          case 8:
            _context.next = 10;
            return asyncCallReturn(iter);

          case 10:
            return _context.abrupt("return", value);

          case 11:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncFirstOr.apply(this, arguments);
}

exports.__asyncFirstOr = __asyncFirstOr;
var asyncFirstOr = /*#__PURE__*/asyncIterableCurry(__asyncFirstOr, {
  reduces: true
});
exports.asyncFirstOr = asyncFirstOr;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],299:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry,
    callReturn = _require.callReturn;

function __firstOr(iterable, whenEmpty) {
  var iter = iterable[Symbol.iterator]();

  var _iter$next = iter.next(),
      value = _iter$next.value,
      done = _iter$next.done;

  if (done) return whenEmpty;
  callReturn(iter);
  return value;
}

exports.__firstOr = __firstOr;
var firstOr = /*#__PURE__*/iterableCurry(__firstOr, {
  reduces: true
});
exports.firstOr = firstOr;
},{"../../internal/iterable.js":493}],300:[function(require,module,exports){
var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$first-or/async-first-or.js'),
    __asyncFirstOr = _require2.__asyncFirstOr;

function __asyncFirst(iterable) {
  return __asyncFirstOr(iterable, undefined);
}

exports.__asyncFirst = __asyncFirst;
var asyncFirst = /*#__PURE__*/asyncIterableCurry(__asyncFirst, {
  reduces: true
});
exports.asyncFirst = asyncFirst;
},{"../$first-or/async-first-or.js":298,"../../internal/async-iterable.js":480}],301:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$first-or/first-or.js'),
    __firstOr = _require2.__firstOr;

function __first(iterable) {
  return __firstOr(iterable, undefined);
}

exports.__first = __first;
var first = /*#__PURE__*/iterableCurry(__first, {
  reduces: true
});
exports.first = first;
},{"../$first-or/first-or.js":299,"../../internal/iterable.js":493}],302:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _asyncGeneratorDelegate = require("@babel/runtime/helpers/asyncGeneratorDelegate");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$map/async-map.js'),
    __asyncMap = _require2.__asyncMap;

function __asyncFlatMap(_x, _x2) {
  return _asyncFlatMap.apply(this, arguments);
}

exports.__asyncFlatMap = __asyncFlatMap;

function _asyncFlatMap() {
  _asyncFlatMap = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, func) {
    var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 2;
            _iterator = _asyncIterator(__asyncMap(source, func));

          case 4:
            _context.next = 6;
            return _awaitAsyncGenerator(_iterator.next());

          case 6:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 10;
            return _awaitAsyncGenerator(_step.value);

          case 10:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 17;
              break;
            }

            value = _value;
            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(value), _awaitAsyncGenerator), "t0", 14);

          case 14:
            _iteratorNormalCompletion = true;
            _context.next = 4;
            break;

          case 17:
            _context.next = 23;
            break;

          case 19:
            _context.prev = 19;
            _context.t1 = _context["catch"](2);
            _didIteratorError = true;
            _iteratorError = _context.t1;

          case 23:
            _context.prev = 23;
            _context.prev = 24;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 28;
              break;
            }

            _context.next = 28;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 28:
            _context.prev = 28;

            if (!_didIteratorError) {
              _context.next = 31;
              break;
            }

            throw _iteratorError;

          case 31:
            return _context.finish(28);

          case 32:
            return _context.finish(23);

          case 33:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[2, 19, 23, 33], [24,, 28, 32]]);
  }));
  return _asyncFlatMap.apply(this, arguments);
}

var asyncFlatMap = /*#__PURE__*/asyncIterableCurry(__asyncFlatMap);
exports.asyncFlatMap = asyncFlatMap;
},{"../$map/async-map.js":337,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncGeneratorDelegate":41,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],303:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__flatMap);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$map/map.js'),
    __map = _require2.__map;

function __flatMap(source, func) {
  var _iterator, _step, value;

  return _regeneratorRuntime.wrap(function __flatMap$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          _iterator = _createForOfIteratorHelper(__map(source, func));
          _context.prev = 1;

          _iterator.s();

        case 3:
          if ((_step = _iterator.n()).done) {
            _context.next = 8;
            break;
          }

          value = _step.value;
          return _context.delegateYield(value, "t0", 6);

        case 6:
          _context.next = 3;
          break;

        case 8:
          _context.next = 13;
          break;

        case 10:
          _context.prev = 10;
          _context.t1 = _context["catch"](1);

          _iterator.e(_context.t1);

        case 13:
          _context.prev = 13;

          _iterator.f();

          return _context.finish(13);

        case 16:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[1, 10, 13, 16]]);
}

exports.__flatMap = __flatMap;
var flatMap = /*#__PURE__*/iterableCurry(__flatMap);
exports.flatMap = flatMap;
},{"../$map/map.js":338,"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],304:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _asyncGeneratorDelegate = require("@babel/runtime/helpers/asyncGeneratorDelegate");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry,
    asyncIsLoopable = _require.asyncIsLoopable;

var _require2 = require('./internal/validate-args.js'),
    validateArgs = _require2.validateArgs;

var defaultShouldFlat = function defaultShouldFlat(value) {
  return typeof value !== 'string' && asyncIsLoopable(value);
};

function asyncFlatInternal(_x, _x2, _x3, _x4) {
  return _asyncFlatInternal.apply(this, arguments);
}

function _asyncFlatInternal() {
  _asyncFlatInternal = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(shouldFlat, depth, currentDepth, source) {
    var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 2;
            _iterator = _asyncIterator(source);

          case 4:
            _context.next = 6;
            return _awaitAsyncGenerator(_iterator.next());

          case 6:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 10;
            return _awaitAsyncGenerator(_step.value);

          case 10:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 27;
              break;
            }

            value = _value;
            _context.t0 = currentDepth < depth;

            if (!_context.t0) {
              _context.next = 18;
              break;
            }

            _context.next = 17;
            return _awaitAsyncGenerator(shouldFlat(value));

          case 17:
            _context.t0 = _context.sent;

          case 18:
            if (!_context.t0) {
              _context.next = 22;
              break;
            }

            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(asyncFlatInternal(shouldFlat, depth, currentDepth + 1, value)), _awaitAsyncGenerator), "t1", 20);

          case 20:
            _context.next = 24;
            break;

          case 22:
            _context.next = 24;
            return value;

          case 24:
            _iteratorNormalCompletion = true;
            _context.next = 4;
            break;

          case 27:
            _context.next = 33;
            break;

          case 29:
            _context.prev = 29;
            _context.t2 = _context["catch"](2);
            _didIteratorError = true;
            _iteratorError = _context.t2;

          case 33:
            _context.prev = 33;
            _context.prev = 34;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 38;
              break;
            }

            _context.next = 38;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 38:
            _context.prev = 38;

            if (!_didIteratorError) {
              _context.next = 41;
              break;
            }

            throw _iteratorError;

          case 41:
            return _context.finish(38);

          case 42:
            return _context.finish(33);

          case 43:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[2, 29, 33, 43], [34,, 38, 42]]);
  }));
  return _asyncFlatInternal.apply(this, arguments);
}

function __asyncFlat(source) {
  var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
  var shouldFlat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultShouldFlat;
  return asyncFlatInternal(shouldFlat, depth, 0, source);
}

exports.__asyncFlat = __asyncFlat;
var asyncFlat = /*#__PURE__*/asyncIterableCurry(__asyncFlat, {
  minArgs: 0,
  maxArgs: 2,
  validateArgs: validateArgs
});
exports.asyncFlat = asyncFlat;
},{"../../internal/async-iterable.js":480,"./internal/validate-args.js":306,"@babel/runtime/helpers/asyncGeneratorDelegate":41,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],305:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(flatInternal);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry,
    isLoopable = _require.isLoopable;

var _require2 = require('./internal/validate-args.js'),
    validateArgs = _require2.validateArgs;

var defaultShouldFlat = function defaultShouldFlat(value) {
  return typeof value !== 'string' && isLoopable(value);
};

function flatInternal(shouldFlat, depth, currentDepth, source) {
  var _iterator, _step, value;

  return _regeneratorRuntime.wrap(function flatInternal$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          _iterator = _createForOfIteratorHelper(source);
          _context.prev = 1;

          _iterator.s();

        case 3:
          if ((_step = _iterator.n()).done) {
            _context.next = 13;
            break;
          }

          value = _step.value;

          if (!(currentDepth < depth && shouldFlat(value))) {
            _context.next = 9;
            break;
          }

          return _context.delegateYield(flatInternal(shouldFlat, depth, currentDepth + 1, value), "t0", 7);

        case 7:
          _context.next = 11;
          break;

        case 9:
          _context.next = 11;
          return value;

        case 11:
          _context.next = 3;
          break;

        case 13:
          _context.next = 18;
          break;

        case 15:
          _context.prev = 15;
          _context.t1 = _context["catch"](1);

          _iterator.e(_context.t1);

        case 18:
          _context.prev = 18;

          _iterator.f();

          return _context.finish(18);

        case 21:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[1, 15, 18, 21]]);
}

function __flat(source) {
  var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
  var shouldFlat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultShouldFlat;
  return flatInternal(shouldFlat, depth, 0, source);
}

exports.__flat = __flat;
var flat = /*#__PURE__*/iterableCurry(__flat, {
  minArgs: 0,
  maxArgs: 2,
  validateArgs: validateArgs
});
exports.flat = flat;
},{"../../internal/iterable.js":493,"./internal/validate-args.js":306,"@babel/runtime/regenerator":65}],306:[function(require,module,exports){
var _require = require('../../is-object/is-object.js'),
    isObject = _require.isObject;

function validateArgs(args) {
  var depthOrOptions = args[1];
  var shouldFlat = args[2];
  var depth = depthOrOptions;

  if (isObject(depthOrOptions)) {
    shouldFlat = depthOrOptions.shouldFlat;
    depth = depthOrOptions.depth;
  }

  args[2] = shouldFlat;
  args[1] = depth;
}

exports.validateArgs = validateArgs;
},{"../../is-object/is-object.js":440}],307:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

function __asyncForEach(_x, _x2) {
  return _asyncForEach.apply(this, arguments);
}

function _asyncForEach() {
  _asyncForEach = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, callback) {
    var c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            c = 0;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 3;
            _iterator = _asyncIterator(iterable);

          case 5:
            _context.next = 7;
            return _iterator.next();

          case 7:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 11;
            return _step.value;

          case 11:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 19;
              break;
            }

            value = _value;
            _context.next = 16;
            return callback(value, c++);

          case 16:
            _iteratorNormalCompletion = true;
            _context.next = 5;
            break;

          case 19:
            _context.next = 25;
            break;

          case 21:
            _context.prev = 21;
            _context.t0 = _context["catch"](3);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 25:
            _context.prev = 25;
            _context.prev = 26;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 30;
              break;
            }

            _context.next = 30;
            return _iterator["return"]();

          case 30:
            _context.prev = 30;

            if (!_didIteratorError) {
              _context.next = 33;
              break;
            }

            throw _iteratorError;

          case 33:
            return _context.finish(30);

          case 34:
            return _context.finish(25);

          case 35:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[3, 21, 25, 35], [26,, 30, 34]]);
  }));
  return _asyncForEach.apply(this, arguments);
}

exports.__asyncForEach = __asyncForEach;
var asyncForEach = /*#__PURE__*/asyncIterableCurry(__asyncForEach, {
  reduces: true
});
exports.asyncForEach = asyncForEach;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],308:[function(require,module,exports){
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

function __forEach(iterable, callback) {
  var c = 0;

  var _iterator = _createForOfIteratorHelper(iterable),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var value = _step.value;
      callback(value, c++);
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }
}

exports.__forEach = __forEach;
var forEach = /*#__PURE__*/iterableCurry(__forEach, {
  reduces: true
});
exports.forEach = forEach;
},{"../../internal/iterable.js":493}],309:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__asyncFork);

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../../internal/async-fork.js'),
    AsyncExchange = _require2.AsyncExchange;

function __asyncFork(source) {
  var exchange, dummyFork;
  return _regeneratorRuntime.wrap(function __asyncFork$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          exchange = new AsyncExchange(source[Symbol.asyncIterator]());
          dummyFork = exchange.fork();
          _context.prev = 2;

        case 3:
          if (!true) {
            _context.next = 8;
            break;
          }

          _context.next = 6;
          return exchange.fork();

        case 6:
          _context.next = 3;
          break;

        case 8:
          _context.prev = 8;
          dummyFork["return"]();
          return _context.finish(8);

        case 11:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[2,, 8, 11]]);
}

exports.__asyncFork = __asyncFork;
var asyncFork = /*#__PURE__*/asyncIterableCurry(__asyncFork, {
  forceSync: true
});
exports.asyncFork = asyncFork;
},{"../../internal/async-fork.js":477,"../../internal/async-iterable.js":480,"@babel/runtime/regenerator":65}],310:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__fork);

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../../internal/fork.js'),
    Exchange = _require2.Exchange;

function __fork(source) {
  var exchange, dummyFork;
  return _regeneratorRuntime.wrap(function __fork$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          exchange = new Exchange(source[Symbol.iterator]());
          dummyFork = exchange.fork();
          _context.prev = 2;

        case 3:
          if (!true) {
            _context.next = 8;
            break;
          }

          _context.next = 6;
          return exchange.fork();

        case 6:
          _context.next = 3;
          break;

        case 8:
          _context.prev = 8;
          dummyFork["return"]();
          return _context.finish(8);

        case 11:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[2,, 8, 11]]);
}

exports.__fork = __fork;
var fork = /*#__PURE__*/iterableCurry(__fork, {
  forceSync: true
});
exports.fork = fork;
},{"../../internal/fork.js":490,"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],311:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

var _createClass = require("@babel/runtime/helpers/createClass");

var _inherits = require("@babel/runtime/helpers/inherits");

var _possibleConstructorReturn = require("@babel/runtime/helpers/possibleConstructorReturn");

var _get = require("@babel/runtime/helpers/get");

var _getPrototypeOf = require("@babel/runtime/helpers/getPrototypeOf");

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }

var _require = require('../../internal/async-iterable.js'),
    asyncEnsureIterable = _require.asyncEnsureIterable;

var _require2 = require('../../internal/async-fork.js'),
    AsyncExchange = _require2.AsyncExchange;

var _require3 = require('../../internal/async-peekerator.js'),
    AsyncPeekerator = _require3.AsyncPeekerator;

var _ = Symbol["for"]('_');

var AsyncForkerator = /*#__PURE__*/function (_AsyncPeekerator) {
  _inherits(AsyncForkerator, _AsyncPeekerator);

  var _super = _createSuper(AsyncForkerator);

  _createClass(AsyncForkerator, null, [{
    key: "from",
    value: function () {
      var _from = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source) {
        var exchange;
        return _regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                exchange = new AsyncExchange(asyncEnsureIterable(source)[Symbol.asyncIterator]());
                _context.next = 3;
                return _get(_getPrototypeOf(AsyncForkerator), "from", this).call(this, exchange.fork(), exchange);

              case 3:
                return _context.abrupt("return", _context.sent);

              case 4:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function from(_x) {
        return _from.apply(this, arguments);
      }

      return from;
    }()
  }]);

  function AsyncForkerator(iterator, first, exchange) {
    var _this;

    _classCallCheck(this, AsyncForkerator);

    _this = _super.call(this, iterator, first);
    _this[_].exchange = exchange;
    return _this;
  }

  _createClass(AsyncForkerator, [{
    key: "advance",
    value: function () {
      var _advance = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
        var n,
            i,
            _args2 = arguments;
        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                n = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : 1;
                i = 0;

              case 2:
                if (!(i < n)) {
                  _context2.next = 9;
                  break;
                }

                _context2.next = 5;
                return _get(_getPrototypeOf(AsyncForkerator.prototype), "advance", this).call(this);

              case 5:
                this[_].exchange.advance();

              case 6:
                i++;
                _context2.next = 2;
                break;

              case 9:
                return _context2.abrupt("return", this);

              case 10:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function advance() {
        return _advance.apply(this, arguments);
      }

      return advance;
    }()
  }, {
    key: "fork",
    value: function fork() {
      return this[_].exchange.fork();
    }
  }, {
    key: Symbol.asyncIterator,
    value: function value() {
      return this[_].exchange.fork();
    }
  }]);

  return AsyncForkerator;
}(AsyncPeekerator);

function __asyncForkerate(source) {
  return AsyncForkerator.from(source);
}

exports.__asyncForkerate = __asyncForkerate;

function asyncWrapWithEnsureIterable(fn) {
  return function (source) {
    return fn(asyncEnsureIterable(source));
  };
}

var asyncForkerate = asyncWrapWithEnsureIterable(__asyncForkerate);
exports.asyncForkerate = asyncForkerate;
},{"../../internal/async-fork.js":477,"../../internal/async-iterable.js":480,"../../internal/async-peekerator.js":483,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/createClass":47,"@babel/runtime/helpers/get":49,"@babel/runtime/helpers/getPrototypeOf":50,"@babel/runtime/helpers/inherits":51,"@babel/runtime/helpers/possibleConstructorReturn":57,"@babel/runtime/regenerator":65}],312:[function(require,module,exports){
var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

var _createClass = require("@babel/runtime/helpers/createClass");

var _inherits = require("@babel/runtime/helpers/inherits");

var _possibleConstructorReturn = require("@babel/runtime/helpers/possibleConstructorReturn");

var _get = require("@babel/runtime/helpers/get");

var _getPrototypeOf = require("@babel/runtime/helpers/getPrototypeOf");

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }

var _require = require('../../internal/iterable.js'),
    ensureIterable = _require.ensureIterable;

var _require2 = require('../../internal/fork.js'),
    Exchange = _require2.Exchange;

var _require3 = require('../../internal/peekerator.js'),
    Peekerator = _require3.Peekerator;

var _ = Symbol["for"]('_');

var Forkerator = /*#__PURE__*/function (_Peekerator) {
  _inherits(Forkerator, _Peekerator);

  var _super = _createSuper(Forkerator);

  _createClass(Forkerator, null, [{
    key: "from",
    value: function from(source) {
      var exchange = new Exchange(ensureIterable(source)[Symbol.iterator]());
      return _get(_getPrototypeOf(Forkerator), "from", this).call(this, exchange.fork(), exchange);
    }
  }]);

  function Forkerator(iterator, first, exchange) {
    var _this;

    _classCallCheck(this, Forkerator);

    _this = _super.call(this, iterator, first);
    _this[_].exchange = exchange;
    return _this;
  }

  _createClass(Forkerator, [{
    key: "advance",
    value: function advance() {
      var n = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;

      for (var i = 0; i < n; i++) {
        _get(_getPrototypeOf(Forkerator.prototype), "advance", this).call(this);

        this[_].exchange.advance();
      }

      return this;
    }
  }, {
    key: "fork",
    value: function fork() {
      return this[_].exchange.fork();
    }
  }, {
    key: Symbol.iterator,
    value: function value() {
      return this[_].exchange.fork();
    }
  }]);

  return Forkerator;
}(Peekerator);

function __forkerate(source) {
  return Forkerator.from(source);
}

exports.__forkerate = __forkerate;

function wrapWithEnsureIterable(fn) {
  return function (source) {
    return fn(ensureIterable(source));
  };
}

var forkerate = wrapWithEnsureIterable(__forkerate);
exports.forkerate = forkerate;
},{"../../internal/fork.js":490,"../../internal/iterable.js":493,"../../internal/peekerator.js":497,"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/createClass":47,"@babel/runtime/helpers/get":49,"@babel/runtime/helpers/getPrototypeOf":50,"@babel/runtime/helpers/inherits":51,"@babel/runtime/helpers/possibleConstructorReturn":57}],313:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../../internal/async-any-seq.js'),
    asyncSeqsToArray = _require2.asyncSeqsToArray;

var _require3 = require('../$window-ahead/async-window-ahead.js'),
    __asyncWindowAhead = _require3.__asyncWindowAhead;

var _require4 = require('../$starts-with-any-seq/starts-with-any-seq.js'),
    __startsWithAnySeq = _require4.__startsWithAnySeq;

function __asyncIncludesAnySeq(_x, _x2) {
  return _asyncIncludesAnySeq.apply(this, arguments);
}

function _asyncIncludesAnySeq() {
  _asyncIncludesAnySeq = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, seqs) {
    var same,
        seqsArr,
        maxMatchLength,
        _iteratorNormalCompletion,
        _didIteratorError,
        _iteratorError,
        _iterator,
        _step,
        _value,
        buffer,
        _args = arguments;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            same = _args.length > 2 && _args[2] !== undefined ? _args[2] : Object.is;
            _context.next = 3;
            return asyncSeqsToArray(seqs);

          case 3:
            seqsArr = _context.sent;

            if (seqsArr.length) {
              _context.next = 6;
              break;
            }

            return _context.abrupt("return", false);

          case 6:
            if (!seqsArr.find(function (seq) {
              return !seq.length;
            })) {
              _context.next = 8;
              break;
            }

            return _context.abrupt("return", true);

          case 8:
            maxMatchLength = seqsArr.reduce(function (max, _ref) {
              var length = _ref.length;
              return Math.max(max, length);
            }, 1);
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 11;
            _iterator = _asyncIterator(__asyncWindowAhead(iterable, maxMatchLength));

          case 13:
            _context.next = 15;
            return _iterator.next();

          case 15:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 19;
            return _step.value;

          case 19:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 27;
              break;
            }

            buffer = _value;

            if (!__startsWithAnySeq(buffer, seqsArr, same)) {
              _context.next = 24;
              break;
            }

            return _context.abrupt("return", true);

          case 24:
            _iteratorNormalCompletion = true;
            _context.next = 13;
            break;

          case 27:
            _context.next = 33;
            break;

          case 29:
            _context.prev = 29;
            _context.t0 = _context["catch"](11);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 33:
            _context.prev = 33;
            _context.prev = 34;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 38;
              break;
            }

            _context.next = 38;
            return _iterator["return"]();

          case 38:
            _context.prev = 38;

            if (!_didIteratorError) {
              _context.next = 41;
              break;
            }

            throw _iteratorError;

          case 41:
            return _context.finish(38);

          case 42:
            return _context.finish(33);

          case 43:
            return _context.abrupt("return", false);

          case 44:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[11, 29, 33, 43], [34,, 38, 42]]);
  }));
  return _asyncIncludesAnySeq.apply(this, arguments);
}

exports.__asyncIncludesAnySeq = __asyncIncludesAnySeq;
var asyncIncludesAnySeq = /*#__PURE__*/asyncIterableCurry(__asyncIncludesAnySeq, {
  minArgs: 1,
  maxArgs: 2,
  reduces: true
});
exports.asyncIncludesAnySeq = asyncIncludesAnySeq;
},{"../$starts-with-any-seq/starts-with-any-seq.js":376,"../$window-ahead/async-window-ahead.js":402,"../../internal/async-any-seq.js":475,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],314:[function(require,module,exports){
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../../internal/any-seq.js'),
    seqsToArray = _require2.seqsToArray;

var _require3 = require('../$window-ahead/window-ahead.js'),
    __windowAhead = _require3.__windowAhead;

var _require4 = require('../$starts-with-any-seq/starts-with-any-seq.js'),
    __startsWithAnySeq = _require4.__startsWithAnySeq;

function __includesAnySeq(iterable, seqs) {
  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;
  var seqsArr = seqsToArray(seqs);
  if (!seqsArr.length) return false;
  if (seqsArr.find(function (seq) {
    return !seq.length;
  })) return true;
  var maxMatchLength = seqsArr.reduce(function (max, _ref) {
    var length = _ref.length;
    return Math.max(max, length);
  }, 1);

  var _iterator = _createForOfIteratorHelper(__windowAhead(iterable, maxMatchLength)),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var buffer = _step.value;

      if (__startsWithAnySeq(buffer, seqsArr, same)) {
        return true;
      }
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

  return false;
}

exports.__includesAnySeq = __includesAnySeq;
var includesAnySeq = /*#__PURE__*/iterableCurry(__includesAnySeq, {
  minArgs: 1,
  maxArgs: 2,
  reduces: true
});
exports.includesAnySeq = includesAnySeq;
},{"../$starts-with-any-seq/starts-with-any-seq.js":376,"../$window-ahead/window-ahead.js":403,"../../internal/any-seq.js":474,"../../internal/iterable.js":493}],315:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$find-or/async-find-or.js'),
    __asyncFindOr = _require2.__asyncFindOr;

var _require3 = require('../$includes/includes.js'),
    __includes = _require3.__includes;

var none = Symbol('none');

function __asyncIncludesAny(_x, _x2) {
  return _asyncIncludesAny.apply(this, arguments);
}

function _asyncIncludesAny() {
  _asyncIncludesAny = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, values) {
    var same,
        _args = arguments;
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            same = _args.length > 2 && _args[2] !== undefined ? _args[2] : Object.is;
            _context.next = 3;
            return __asyncFindOr(iterable, none, function (value) {
              return __includes(values, value, function (a, b) {
                return same(b, a);
              });
            });

          case 3:
            _context.t0 = _context.sent;
            _context.t1 = none;
            return _context.abrupt("return", _context.t0 !== _context.t1);

          case 6:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncIncludesAny.apply(this, arguments);
}

exports.__asyncIncludesAny = __asyncIncludesAny;
var asyncIncludesAny = /*#__PURE__*/asyncIterableCurry(__asyncIncludesAny, {
  minArgs: 1,
  maxArgs: 2,
  reduces: true,
  validateArgs: function validateArgs(args) {}
});
exports.asyncIncludesAny = asyncIncludesAny;
},{"../$find-or/async-find-or.js":294,"../$includes/includes.js":320,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],316:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$find-or/find-or.js'),
    __findOr = _require2.__findOr;

var _require3 = require('../$includes/includes.js'),
    __includes = _require3.__includes;

var none = Symbol('none');

function __includesAny(iterable, values) {
  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;
  return __findOr(iterable, none, function (value) {
    return __includes(values, value, function (a, b) {
      return same(b, a);
    });
  }) !== none;
}

exports.__includesAny = __includesAny;
var includesAny = /*#__PURE__*/iterableCurry(__includesAny, {
  minArgs: 1,
  maxArgs: 2,
  reduces: true,
  validateArgs: function validateArgs(args) {
    if (true && typeof args[0] === 'string') {
      console.warn("For string inputs use includesAnySeq instead of includesAny");
    }
  }
});
exports.includesAny = includesAny;
},{"../$find-or/find-or.js":295,"../$includes/includes.js":320,"../../internal/iterable.js":493}],317:[function(require,module,exports){
var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry,
    asyncEnsureIterable = _require.asyncEnsureIterable;

var _require2 = require('../$includes-any-seq/async-includes-any-seq.js'),
    __asyncIncludesAnySeq = _require2.__asyncIncludesAnySeq;

function __asyncIncludesSeq(iterable, seq) {
  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;
  return __asyncIncludesAnySeq(iterable, [seq], same);
}

exports.__asyncIncludesSeq = __asyncIncludesSeq;
var asyncIncludesSeq = /*#__PURE__*/asyncIterableCurry(__asyncIncludesSeq, {
  minArgs: 1,
  maxArgs: 2,
  reduces: true,
  validateArgs: function validateArgs(args) {
    args[1] = asyncEnsureIterable(args[1]);
  }
});
exports.asyncIncludesSeq = asyncIncludesSeq;
},{"../$includes-any-seq/async-includes-any-seq.js":313,"../../internal/async-iterable.js":480}],318:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry,
    ensureIterable = _require.ensureIterable;

var _require2 = require('../$includes-any-seq/includes-any-seq.js'),
    __includesAnySeq = _require2.__includesAnySeq;

function __includesSeq(iterable, seq) {
  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;
  return __includesAnySeq(iterable, [seq], same);
}

exports.__includesSeq = __includesSeq;
var includesSeq = /*#__PURE__*/iterableCurry(__includesSeq, {
  minArgs: 1,
  maxArgs: 2,
  reduces: true,
  validateArgs: function validateArgs(args) {
    args[1] = ensureIterable(args[1]);
  }
});
exports.includesSeq = includesSeq;
},{"../$includes-any-seq/includes-any-seq.js":314,"../../internal/iterable.js":493}],319:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$find-or/async-find-or.js'),
    __asyncFindOr = _require2.__asyncFindOr;

var none = Symbol('none');

function __asyncIncludes(_x, _x2) {
  return _asyncIncludes.apply(this, arguments);
}

function _asyncIncludes() {
  _asyncIncludes = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, value) {
    var same,
        _args = arguments;
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            same = _args.length > 2 && _args[2] !== undefined ? _args[2] : Object.is;
            _context.next = 3;
            return __asyncFindOr(iterable, none, function (v) {
              return same(value, v);
            });

          case 3:
            _context.t0 = _context.sent;
            _context.t1 = none;
            return _context.abrupt("return", _context.t0 !== _context.t1);

          case 6:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncIncludes.apply(this, arguments);
}

exports.__asyncIncludes = __asyncIncludes;
var asyncIncludes = /*#__PURE__*/asyncIterableCurry(__asyncIncludes, {
  minArgs: 1,
  maxArgs: 2,
  reduces: true,
  validateArgs: function validateArgs(args) {}
});
exports.asyncIncludes = asyncIncludes;
},{"../$find-or/async-find-or.js":294,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],320:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$find-or/find-or.js'),
    __findOr = _require2.__findOr;

var none = Symbol('none');

function __includes(iterable, value) {
  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;
  return __findOr(iterable, none, function (v) {
    return same(value, v);
  }) !== none;
}

exports.__includes = __includes;
var includes = /*#__PURE__*/iterableCurry(__includes, {
  minArgs: 1,
  maxArgs: 2,
  reduces: true,
  validateArgs: function validateArgs(args) {
    if (true && typeof args[0] === 'string') {
      console.warn("For string inputs use includesSeq instead of includes");
    }
  }
});
exports.includes = includes;
},{"../$find-or/find-or.js":295,"../../internal/iterable.js":493}],321:[function(require,module,exports){
var _toConsumableArray = require("@babel/runtime/helpers/toConsumableArray");

var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

var _createClass = require("@babel/runtime/helpers/createClass");

var _get = require("@babel/runtime/helpers/get");

var _inherits = require("@babel/runtime/helpers/inherits");

var _possibleConstructorReturn = require("@babel/runtime/helpers/possibleConstructorReturn");

var _getPrototypeOf = require("@babel/runtime/helpers/getPrototypeOf");

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry,
    asyncCallReturn = _require.asyncCallReturn;

var _require2 = require('../../internal/async-iterable-iterator.js'),
    AsyncIterableIterator = _require2.AsyncIterableIterator;

var _require3 = require('../../internal/async-parallel-each.js'),
    asyncParallelEach = _require3.asyncParallelEach;

var _require4 = require('../../internal/async-peekerator.js'),
    AsyncPeekerator = _require4.AsyncPeekerator;

var _require5 = require('../$map/async-map.js'),
    __asyncMap = _require5.__asyncMap;

var _require6 = require('../$to-array/async-to-array.js'),
    __asyncToArray = _require6.__asyncToArray;

var _ = Symbol["for"]('_');

var __advance = Symbol["for"]('__advance');

var AsyncSummarizedPeekerator = /*#__PURE__*/function (_AsyncPeekerator) {
  _inherits(AsyncSummarizedPeekerator, _AsyncPeekerator);

  var _super = _createSuper(AsyncSummarizedPeekerator);

  function AsyncSummarizedPeekerator(iterator, first, inputSummary) {
    var _this;

    _classCallCheck(this, AsyncSummarizedPeekerator);

    _this = _super.call(this, iterator, first);
    _this[_].inputSummary = inputSummary;
    return _this;
  }

  _createClass(AsyncSummarizedPeekerator, [{
    key: "advance",
    value: function () {
      var _advance = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
        return _regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.next = 2;
                return this[_].inputSummary.advanceBuffer(this);

              case 2:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function advance() {
        return _advance.apply(this, arguments);
      }

      return advance;
    }()
  }, {
    key: __advance,
    value: function () {
      var _value = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                _context2.next = 2;
                return _get(_getPrototypeOf(AsyncSummarizedPeekerator.prototype), "advance", this).call(this);

              case 2:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function value() {
        return _value.apply(this, arguments);
      }

      return value;
    }()
  }]);

  return AsyncSummarizedPeekerator;
}(AsyncPeekerator);

var AsyncInputSummaryInternal = /*#__PURE__*/function () {
  function AsyncInputSummaryInternal() {
    _classCallCheck(this, AsyncInputSummaryInternal);

    this.buffers = [];
    this.notDoneBuffer = null;
    this.index = 0;
  }

  _createClass(AsyncInputSummaryInternal, [{
    key: "init",
    value: function init(buffers) {
      this.buffers = buffers;
      this.updateNotDone();
    }
  }, {
    key: "updateNotDone",
    value: function updateNotDone() {
      this.notDoneBuffer = this.buffers.find(function (buffer) {
        return !buffer.done;
      });
    }
  }, {
    key: "advanceBuffer",
    value: function () {
      var _advanceBuffer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(buffer) {
        var wasDone;
        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                wasDone = buffer.done;
                _context3.next = 3;
                return buffer[__advance]();

              case 3:
                this.index++;

                if (!wasDone && buffer.done) {
                  this.updateNotDone();
                }

              case 5:
              case "end":
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      function advanceBuffer(_x) {
        return _advanceBuffer.apply(this, arguments);
      }

      return advanceBuffer;
    }()
  }]);

  return AsyncInputSummaryInternal;
}();

var AsyncInputSummary = /*#__PURE__*/function () {
  function AsyncInputSummary(internal) {
    _classCallCheck(this, AsyncInputSummary);

    this[_] = internal;
  }

  _createClass(AsyncInputSummary, [{
    key: "advance",
    value: function advance() {
      throw new Error('advance() is not supported on an interleave summary');
    }
  }, {
    key: "current",
    get: function get() {
      return {
        value: this.value,
        done: this.done
      };
    }
  }, {
    key: "value",
    get: function get() {
      return this[_].notDoneBuffer;
    }
  }, {
    key: "done",
    get: function get() {
      return this[_].notDoneBuffer === undefined;
    }
  }, {
    key: "index",
    get: function get() {
      return this[_].index;
    }
  }]);

  return AsyncInputSummary;
}();

exports.AsyncInputSummary = AsyncInputSummary;

var AsyncInterleaver = /*#__PURE__*/function (_AsyncIterableIterato) {
  _inherits(AsyncInterleaver, _AsyncIterableIterato);

  var _super2 = _createSuper(AsyncInterleaver);

  function AsyncInterleaver(sources, strategy, options) {
    var _this2;

    _classCallCheck(this, AsyncInterleaver);

    _this2 = _super2.call(this);
    _this2.sources = sources;
    _this2.strategy = strategy;
    _this2.options = options;
    _this2.initialized = false;
    _this2.inputSummary = new AsyncInputSummaryInternal(sources);
    return _this2;
  }

  _createClass(AsyncInterleaver, [{
    key: "init",
    value: function () {
      var _init = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
        var strategy, options, inputSummary;
        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                this.initialized = true;
                strategy = this.strategy, options = this.options, inputSummary = this.inputSummary;
                _context4.next = 4;
                return __asyncToArray(__asyncMap(this.sources, function (source) {
                  return AsyncSummarizedPeekerator.from(source, inputSummary);
                }));

              case 4:
                this.buffers = _context4.sent;
                this.iterator = strategy.apply(void 0, [options, new AsyncInputSummary(inputSummary)].concat(_toConsumableArray(this.buffers)));
                _context4.next = 8;
                return inputSummary.init(this.buffers);

              case 8:
              case "end":
                return _context4.stop();
            }
          }
        }, _callee4, this);
      }));

      function init() {
        return _init.apply(this, arguments);
      }

      return init;
    }()
  }, {
    key: "returnBuffers",
    value: function () {
      var _returnBuffers = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                _context5.next = 2;
                return asyncParallelEach(this.buffers, function (buffer) {
                  return buffer["return"]();
                });

              case 2:
              case "end":
                return _context5.stop();
            }
          }
        }, _callee5, this);
      }));

      function returnBuffers() {
        return _returnBuffers.apply(this, arguments);
      }

      return returnBuffers;
    }()
  }, {
    key: "next",
    value: function () {
      var _next = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
        var step;
        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
          while (1) {
            switch (_context6.prev = _context6.next) {
              case 0:
                if (this.initialized) {
                  _context6.next = 3;
                  break;
                }

                _context6.next = 3;
                return this.init();

              case 3:
                _context6.next = 5;
                return this.iterator.next();

              case 5:
                step = _context6.sent;

                if (!step.done) {
                  _context6.next = 9;
                  break;
                }

                _context6.next = 9;
                return this.returnBuffers();

              case 9:
                return _context6.abrupt("return", step);

              case 10:
              case "end":
                return _context6.stop();
            }
          }
        }, _callee6, this);
      }));

      function next() {
        return _next.apply(this, arguments);
      }

      return next;
    }()
  }, {
    key: "return",
    value: function () {
      var _return2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
        return _regeneratorRuntime.wrap(function _callee7$(_context7) {
          while (1) {
            switch (_context7.prev = _context7.next) {
              case 0:
                _context7.next = 2;
                return asyncCallReturn(this.iterator);

              case 2:
                _context7.next = 4;
                return this.returnBuffers();

              case 4:
                return _context7.abrupt("return", {
                  value: undefined,
                  done: true
                });

              case 5:
              case "end":
                return _context7.stop();
            }
          }
        }, _callee7, this);
      }));

      function _return() {
        return _return2.apply(this, arguments);
      }

      return _return;
    }()
  }]);

  return AsyncInterleaver;
}(AsyncIterableIterator);

function __asyncInterleave(sources, strategy) {
  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  return new AsyncInterleaver(sources, strategy, options);
}

exports.__asyncInterleave = __asyncInterleave;
var asyncInterleave = /*#__PURE__*/asyncIterableCurry(__asyncInterleave, {
  variadic: true,
  growRight: true,
  minArgs: 1,
  maxArgs: 2
});
exports.asyncInterleave = asyncInterleave;
},{"../$map/async-map.js":337,"../$to-array/async-to-array.js":398,"../../internal/async-iterable-iterator.js":479,"../../internal/async-iterable.js":480,"../../internal/async-parallel-each.js":481,"../../internal/async-peekerator.js":483,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/createClass":47,"@babel/runtime/helpers/get":49,"@babel/runtime/helpers/getPrototypeOf":50,"@babel/runtime/helpers/inherits":51,"@babel/runtime/helpers/possibleConstructorReturn":57,"@babel/runtime/helpers/toConsumableArray":61,"@babel/runtime/regenerator":65}],322:[function(require,module,exports){
var _toConsumableArray = require("@babel/runtime/helpers/toConsumableArray");

var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

var _createClass = require("@babel/runtime/helpers/createClass");

var _get = require("@babel/runtime/helpers/get");

var _inherits = require("@babel/runtime/helpers/inherits");

var _possibleConstructorReturn = require("@babel/runtime/helpers/possibleConstructorReturn");

var _getPrototypeOf = require("@babel/runtime/helpers/getPrototypeOf");

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry,
    callReturn = _require.callReturn;

var _require2 = require('../../internal/iterable-iterator.js'),
    IterableIterator = _require2.IterableIterator;

var _require3 = require('../../internal/parallel-each.js'),
    parallelEach = _require3.parallelEach;

var _require4 = require('../../internal/peekerator.js'),
    Peekerator = _require4.Peekerator;

var _require5 = require('../$map/map.js'),
    __map = _require5.__map;

var _require6 = require('../$to-array/to-array.js'),
    __toArray = _require6.__toArray;

var _ = Symbol["for"]('_');

var __advance = Symbol["for"]('__advance');

var SummarizedPeekerator = /*#__PURE__*/function (_Peekerator) {
  _inherits(SummarizedPeekerator, _Peekerator);

  var _super = _createSuper(SummarizedPeekerator);

  function SummarizedPeekerator(iterator, first, inputSummary) {
    var _this;

    _classCallCheck(this, SummarizedPeekerator);

    _this = _super.call(this, iterator, first);
    _this[_].inputSummary = inputSummary;
    return _this;
  }

  _createClass(SummarizedPeekerator, [{
    key: "advance",
    value: function advance() {
      this[_].inputSummary.advanceBuffer(this);
    }
  }, {
    key: __advance,
    value: function value() {
      _get(_getPrototypeOf(SummarizedPeekerator.prototype), "advance", this).call(this);
    }
  }]);

  return SummarizedPeekerator;
}(Peekerator);

var InputSummaryInternal = /*#__PURE__*/function () {
  function InputSummaryInternal() {
    _classCallCheck(this, InputSummaryInternal);

    this.buffers = [];
    this.notDoneBuffer = null;
    this.index = 0;
  }

  _createClass(InputSummaryInternal, [{
    key: "init",
    value: function init(buffers) {
      this.buffers = buffers;
      this.updateNotDone();
    }
  }, {
    key: "updateNotDone",
    value: function updateNotDone() {
      this.notDoneBuffer = this.buffers.find(function (buffer) {
        return !buffer.done;
      });
    }
  }, {
    key: "advanceBuffer",
    value: function advanceBuffer(buffer) {
      var wasDone = buffer.done;

      buffer[__advance]();

      this.index++;

      if (!wasDone && buffer.done) {
        this.updateNotDone();
      }
    }
  }]);

  return InputSummaryInternal;
}();

var InputSummary = /*#__PURE__*/function () {
  function InputSummary(internal) {
    _classCallCheck(this, InputSummary);

    this[_] = internal;
  }

  _createClass(InputSummary, [{
    key: "advance",
    value: function advance() {
      throw new Error('advance() is not supported on an interleave summary');
    }
  }, {
    key: "current",
    get: function get() {
      return {
        value: this.value,
        done: this.done
      };
    }
  }, {
    key: "value",
    get: function get() {
      return this[_].notDoneBuffer;
    }
  }, {
    key: "done",
    get: function get() {
      return this[_].notDoneBuffer === undefined;
    }
  }, {
    key: "index",
    get: function get() {
      return this[_].index;
    }
  }]);

  return InputSummary;
}();

exports.InputSummary = InputSummary;

var Interleaver = /*#__PURE__*/function (_IterableIterator) {
  _inherits(Interleaver, _IterableIterator);

  var _super2 = _createSuper(Interleaver);

  function Interleaver(sources, strategy, options) {
    var _this2;

    _classCallCheck(this, Interleaver);

    _this2 = _super2.call(this);
    _this2.sources = sources;
    _this2.strategy = strategy;
    _this2.options = options;
    _this2.initialized = false;
    _this2.inputSummary = new InputSummaryInternal(sources);
    return _this2;
  }

  _createClass(Interleaver, [{
    key: "init",
    value: function init() {
      this.initialized = true;
      var strategy = this.strategy,
          options = this.options,
          inputSummary = this.inputSummary;
      this.buffers = __toArray(__map(this.sources, function (source) {
        return SummarizedPeekerator.from(source, inputSummary);
      }));
      this.iterator = strategy.apply(void 0, [options, new InputSummary(inputSummary)].concat(_toConsumableArray(this.buffers)));
      inputSummary.init(this.buffers);
    }
  }, {
    key: "returnBuffers",
    value: function returnBuffers() {
      parallelEach(this.buffers, function (buffer) {
        return buffer["return"]();
      });
    }
  }, {
    key: "next",
    value: function next() {
      if (!this.initialized) this.init();
      var step = this.iterator.next();
      if (step.done) this.returnBuffers();
      return step;
    }
  }, {
    key: "return",
    value: function _return() {
      callReturn(this.iterator);
      this.returnBuffers();
      return {
        value: undefined,
        done: true
      };
    }
  }]);

  return Interleaver;
}(IterableIterator);

function __interleave(sources, strategy) {
  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  return new Interleaver(sources, strategy, options);
}

exports.__interleave = __interleave;
var interleave = /*#__PURE__*/iterableCurry(__interleave, {
  variadic: true,
  growRight: true,
  minArgs: 1,
  maxArgs: 2
});
exports.interleave = interleave;
},{"../$map/map.js":338,"../$to-array/to-array.js":399,"../../internal/iterable-iterator.js":492,"../../internal/iterable.js":493,"../../internal/parallel-each.js":495,"../../internal/peekerator.js":497,"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/createClass":47,"@babel/runtime/helpers/get":49,"@babel/runtime/helpers/getPrototypeOf":50,"@babel/runtime/helpers/inherits":51,"@babel/runtime/helpers/possibleConstructorReturn":57,"@babel/runtime/helpers/toConsumableArray":61}],323:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _asyncGeneratorDelegate = require("@babel/runtime/helpers/asyncGeneratorDelegate");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry,
    asyncCache = _require.asyncCache;

function __asyncInterposeSeq(_x, _x2) {
  return _asyncInterposeSeq.apply(this, arguments);
}

exports.__asyncInterposeSeq = __asyncInterposeSeq;

function _asyncInterposeSeq() {
  _asyncInterposeSeq = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, seq) {
    var subseq_, first, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, sourceValue;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.next = 2;
            return _awaitAsyncGenerator(asyncCache(seq));

          case 2:
            subseq_ = _context.sent;
            first = true;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 6;
            _iterator = _asyncIterator(source);

          case 8:
            _context.next = 10;
            return _awaitAsyncGenerator(_iterator.next());

          case 10:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 14;
            return _awaitAsyncGenerator(_step.value);

          case 14:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 25;
              break;
            }

            sourceValue = _value;

            if (first) {
              _context.next = 19;
              break;
            }

            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(subseq_), _awaitAsyncGenerator), "t0", 19);

          case 19:
            _context.next = 21;
            return sourceValue;

          case 21:
            first = false;

          case 22:
            _iteratorNormalCompletion = true;
            _context.next = 8;
            break;

          case 25:
            _context.next = 31;
            break;

          case 27:
            _context.prev = 27;
            _context.t1 = _context["catch"](6);
            _didIteratorError = true;
            _iteratorError = _context.t1;

          case 31:
            _context.prev = 31;
            _context.prev = 32;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 36;
              break;
            }

            _context.next = 36;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 36:
            _context.prev = 36;

            if (!_didIteratorError) {
              _context.next = 39;
              break;
            }

            throw _iteratorError;

          case 39:
            return _context.finish(36);

          case 40:
            return _context.finish(31);

          case 41:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[6, 27, 31, 41], [32,, 36, 40]]);
  }));
  return _asyncInterposeSeq.apply(this, arguments);
}

var asyncInterposeSeq = /*#__PURE__*/asyncIterableCurry(__asyncInterposeSeq);
exports.asyncInterposeSeq = asyncInterposeSeq;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncGeneratorDelegate":41,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],324:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__interposeSeq);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry,
    cache = _require.cache;

function __interposeSeq(source, seq) {
  var subseq_, first, _iterator, _step, sourceValue;

  return _regeneratorRuntime.wrap(function __interposeSeq$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          subseq_ = cache(seq);
          first = true;
          _iterator = _createForOfIteratorHelper(source);
          _context.prev = 3;

          _iterator.s();

        case 5:
          if ((_step = _iterator.n()).done) {
            _context.next = 14;
            break;
          }

          sourceValue = _step.value;

          if (first) {
            _context.next = 9;
            break;
          }

          return _context.delegateYield(subseq_, "t0", 9);

        case 9:
          _context.next = 11;
          return sourceValue;

        case 11:
          first = false;

        case 12:
          _context.next = 5;
          break;

        case 14:
          _context.next = 19;
          break;

        case 16:
          _context.prev = 16;
          _context.t1 = _context["catch"](3);

          _iterator.e(_context.t1);

        case 19:
          _context.prev = 19;

          _iterator.f();

          return _context.finish(19);

        case 22:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[3, 16, 19, 22]]);
}

exports.__interposeSeq = __interposeSeq;
var interposeSeq = /*#__PURE__*/iterableCurry(__interposeSeq);
exports.interposeSeq = interposeSeq;
},{"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],325:[function(require,module,exports){
var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$interpose-seq/async-interpose-seq.js'),
    __asyncInterposeSeq = _require2.__asyncInterposeSeq;

function __asyncInterpose(source, value) {
  return __asyncInterposeSeq(source, [value]);
}

exports.__asyncInterpose = __asyncInterpose;
var asyncInterpose = /*#__PURE__*/asyncIterableCurry(__asyncInterpose, {
  validateArgs: function validateArgs(args) {}
});
exports.asyncInterpose = asyncInterpose;
},{"../$interpose-seq/async-interpose-seq.js":323,"../../internal/async-iterable.js":480}],326:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$interpose-seq/interpose-seq.js'),
    __interposeSeq = _require2.__interposeSeq;

function __interpose(source, value) {
  return __interposeSeq(source, [value]);
}

exports.__interpose = __interpose;
var interpose = /*#__PURE__*/iterableCurry(__interpose, {
  validateArgs: function validateArgs(args) {
    if (true && typeof args[0] === 'string') {
      console.warn("For string inputs use interposeSeq instead of interpose");
    }
  }
});
exports.interpose = interpose;
},{"../$interpose-seq/interpose-seq.js":324,"../../internal/iterable.js":493}],327:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$first-or/async-first-or.js'),
    __asyncFirstOr = _require2.__asyncFirstOr;

var none = Symbol('none');

function __asyncIsEmpty(_x) {
  return _asyncIsEmpty.apply(this, arguments);
}

function _asyncIsEmpty() {
  _asyncIsEmpty = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable) {
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.next = 2;
            return __asyncFirstOr(iterable, none);

          case 2:
            _context.t0 = _context.sent;
            _context.t1 = none;
            return _context.abrupt("return", _context.t0 === _context.t1);

          case 5:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncIsEmpty.apply(this, arguments);
}

exports.__asyncIsEmpty = __asyncIsEmpty;
var asyncIsEmpty = /*#__PURE__*/asyncIterableCurry(__asyncIsEmpty, {
  reduces: true
});
exports.asyncIsEmpty = asyncIsEmpty;
},{"../$first-or/async-first-or.js":298,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],328:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$first-or/first-or.js'),
    __firstOr = _require2.__firstOr;

var none = Symbol('none');

function __isEmpty(iterable) {
  return __firstOr(iterable, none) === none;
}

exports.__isEmpty = __isEmpty;
var isEmpty = /*#__PURE__*/iterableCurry(__isEmpty, {
  reduces: true
});
exports.isEmpty = isEmpty;
},{"../$first-or/first-or.js":299,"../../internal/iterable.js":493}],329:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../../internal/compare.js'),
    defaultCompareOrder = _require2.defaultCompareOrder;

var _require3 = require('../$peekerate/async-peekerate.js'),
    __asyncPeekerate = _require3.__asyncPeekerate;

function __asyncIsSorted(_x) {
  return _asyncIsSorted.apply(this, arguments);
}

function _asyncIsSorted() {
  _asyncIsSorted = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable) {
    var compare,
        peekr,
        value,
        _args = arguments;
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            compare = _args.length > 1 && _args[1] !== undefined ? _args[1] : defaultCompareOrder;
            _context.next = 3;
            return __asyncPeekerate(iterable);

          case 3:
            peekr = _context.sent;

          case 4:
            if (peekr.done) {
              _context.next = 14;
              break;
            }

            value = peekr.value;
            _context.next = 8;
            return peekr.advance();

          case 8:
            if (!(!peekr.done && compare(value, peekr.value) > 0)) {
              _context.next = 12;
              break;
            }

            _context.next = 11;
            return peekr["return"]();

          case 11:
            return _context.abrupt("return", false);

          case 12:
            _context.next = 4;
            break;

          case 14:
            return _context.abrupt("return", true);

          case 15:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncIsSorted.apply(this, arguments);
}

exports.__asyncIsSorted = __asyncIsSorted;
var asyncIsSorted = /*#__PURE__*/asyncIterableCurry(__asyncIsSorted, {
  reduces: true,
  minArgs: 0,
  maxArgs: 1
});
exports.asyncIsSorted = asyncIsSorted;
},{"../$peekerate/async-peekerate.js":339,"../../internal/async-iterable.js":480,"../../internal/compare.js":487,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],330:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../../internal/compare.js'),
    defaultCompareOrder = _require2.defaultCompareOrder;

var _require3 = require('../$peekerate/peekerate.js'),
    __peekerate = _require3.__peekerate;

function __isSorted(iterable) {
  var compare = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultCompareOrder;

  var peekr = __peekerate(iterable);

  while (!peekr.done) {
    var value = peekr.value;
    peekr.advance();

    if (!peekr.done && compare(value, peekr.value) > 0) {
      peekr["return"]();
      return false;
    }
  }

  return true;
}

exports.__isSorted = __isSorted;
var isSorted = /*#__PURE__*/iterableCurry(__isSorted, {
  reduces: true,
  minArgs: 0,
  maxArgs: 1
});
exports.isSorted = isSorted;
},{"../$peekerate/peekerate.js":340,"../../internal/compare.js":487,"../../internal/iterable.js":493}],331:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _asyncGeneratorDelegate = require("@babel/runtime/helpers/asyncGeneratorDelegate");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$to-array/async-to-array.js'),
    __asyncToArray = _require2.__asyncToArray;

function __asyncJoinWithSeq(_x, _x2) {
  return _asyncJoinWithSeq.apply(this, arguments);
}

exports.__asyncJoinWithSeq = __asyncJoinWithSeq;

function _asyncJoinWithSeq() {
  _asyncJoinWithSeq = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, separatorSeq) {
    var _separatorSeq, isFirst, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.next = 2;
            return _awaitAsyncGenerator(__asyncToArray(separatorSeq));

          case 2:
            _separatorSeq = _context.sent;
            isFirst = true;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 6;
            _iterator = _asyncIterator(source);

          case 8:
            _context.next = 10;
            return _awaitAsyncGenerator(_iterator.next());

          case 10:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 14;
            return _awaitAsyncGenerator(_step.value);

          case 14:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 24;
              break;
            }

            value = _value;

            if (isFirst) {
              _context.next = 19;
              break;
            }

            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(_separatorSeq), _awaitAsyncGenerator), "t0", 19);

          case 19:
            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(value), _awaitAsyncGenerator), "t1", 20);

          case 20:
            isFirst = false;

          case 21:
            _iteratorNormalCompletion = true;
            _context.next = 8;
            break;

          case 24:
            _context.next = 30;
            break;

          case 26:
            _context.prev = 26;
            _context.t2 = _context["catch"](6);
            _didIteratorError = true;
            _iteratorError = _context.t2;

          case 30:
            _context.prev = 30;
            _context.prev = 31;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 35;
              break;
            }

            _context.next = 35;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 35:
            _context.prev = 35;

            if (!_didIteratorError) {
              _context.next = 38;
              break;
            }

            throw _iteratorError;

          case 38:
            return _context.finish(35);

          case 39:
            return _context.finish(30);

          case 40:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[6, 26, 30, 40], [31,, 35, 39]]);
  }));
  return _asyncJoinWithSeq.apply(this, arguments);
}

var asyncJoinWithSeq = /*#__PURE__*/asyncIterableCurry(__asyncJoinWithSeq);
exports.asyncJoinWithSeq = asyncJoinWithSeq;
},{"../$to-array/async-to-array.js":398,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncGeneratorDelegate":41,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],332:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__joinWithSeq);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$to-array/to-array.js'),
    __toArray = _require2.__toArray;

function __joinWithSeq(source, separatorSeq) {
  var _separatorSeq, isFirst, _iterator, _step, value;

  return _regeneratorRuntime.wrap(function __joinWithSeq$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          _separatorSeq = __toArray(separatorSeq);
          isFirst = true;
          _iterator = _createForOfIteratorHelper(source);
          _context.prev = 3;

          _iterator.s();

        case 5:
          if ((_step = _iterator.n()).done) {
            _context.next = 13;
            break;
          }

          value = _step.value;

          if (isFirst) {
            _context.next = 9;
            break;
          }

          return _context.delegateYield(_separatorSeq, "t0", 9);

        case 9:
          return _context.delegateYield(value, "t1", 10);

        case 10:
          isFirst = false;

        case 11:
          _context.next = 5;
          break;

        case 13:
          _context.next = 18;
          break;

        case 15:
          _context.prev = 15;
          _context.t2 = _context["catch"](3);

          _iterator.e(_context.t2);

        case 18:
          _context.prev = 18;

          _iterator.f();

          return _context.finish(18);

        case 21:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[3, 15, 18, 21]]);
}

exports.__joinWithSeq = __joinWithSeq;
var joinWithSeq = /*#__PURE__*/iterableCurry(__joinWithSeq);
exports.joinWithSeq = joinWithSeq;
},{"../$to-array/to-array.js":399,"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],333:[function(require,module,exports){
var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$join-with-seq/async-join-with-seq.js'),
    __asyncJoinWithSeq = _require2.__asyncJoinWithSeq;

function __asyncJoinWith(source, separator) {
  return __asyncJoinWithSeq(source, [separator]);
}

exports.__asyncJoinWith = __asyncJoinWith;
var asyncJoinWith = /*#__PURE__*/asyncIterableCurry(__asyncJoinWith, {
  validateArgs: function validateArgs(args) {}
});
exports.asyncJoinWith = asyncJoinWith;
},{"../$join-with-seq/async-join-with-seq.js":331,"../../internal/async-iterable.js":480}],334:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$join-with-seq/join-with-seq.js'),
    __joinWithSeq = _require2.__joinWithSeq;

function __joinWith(source, separator) {
  return __joinWithSeq(source, [separator]);
}

exports.__joinWith = __joinWith;
var joinWith = /*#__PURE__*/iterableCurry(__joinWith, {
  validateArgs: function validateArgs(args) {
    if (true && typeof args[0] === 'string') {
      console.warn("For string inputs use joinWithSeq instead of joinWith");
    }
  }
});
exports.joinWith = joinWith;
},{"../$join-with-seq/join-with-seq.js":332,"../../internal/iterable.js":493}],335:[function(require,module,exports){
var _require = require('../../internal/async-iterable.js'),
    asyncWrapWithIterableIterator = _require.asyncWrapWithIterableIterator,
    asyncEnsureIterable = _require.asyncEnsureIterable;

var _require2 = require('../$join-with-seq/async-join-with-seq.js'),
    __asyncJoinWithSeq = _require2.__asyncJoinWithSeq;

var emptySeq = [];

function __asyncJoin(source) {
  return __asyncJoinWithSeq(asyncEnsureIterable(source), emptySeq);
}

exports.__asyncJoin = __asyncJoin;
var asyncJoin = /*#__PURE__*/asyncWrapWithIterableIterator(__asyncJoin);
exports.asyncJoin = asyncJoin;
},{"../$join-with-seq/async-join-with-seq.js":331,"../../internal/async-iterable.js":480}],336:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    wrapWithIterableIterator = _require.wrapWithIterableIterator,
    ensureIterable = _require.ensureIterable;

var _require2 = require('../$join-with-seq/join-with-seq.js'),
    __joinWithSeq = _require2.__joinWithSeq;

var emptySeq = [];

function __join(source) {
  return __joinWithSeq(ensureIterable(source), emptySeq);
}

exports.__join = __join;
var join = /*#__PURE__*/wrapWithIterableIterator(__join);
exports.join = join;
},{"../$join-with-seq/join-with-seq.js":332,"../../internal/iterable.js":493}],337:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

function __asyncMap(_x, _x2) {
  return _asyncMap.apply(this, arguments);
}

exports.__asyncMap = __asyncMap;

function _asyncMap() {
  _asyncMap = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, func) {
    var c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            c = 0;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 3;
            _iterator = _asyncIterator(source);

          case 5:
            _context.next = 7;
            return _awaitAsyncGenerator(_iterator.next());

          case 7:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 11;
            return _awaitAsyncGenerator(_step.value);

          case 11:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 19;
              break;
            }

            value = _value;
            _context.next = 16;
            return func(value, c++);

          case 16:
            _iteratorNormalCompletion = true;
            _context.next = 5;
            break;

          case 19:
            _context.next = 25;
            break;

          case 21:
            _context.prev = 21;
            _context.t0 = _context["catch"](3);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 25:
            _context.prev = 25;
            _context.prev = 26;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 30;
              break;
            }

            _context.next = 30;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 30:
            _context.prev = 30;

            if (!_didIteratorError) {
              _context.next = 33;
              break;
            }

            throw _iteratorError;

          case 33:
            return _context.finish(30);

          case 34:
            return _context.finish(25);

          case 35:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[3, 21, 25, 35], [26,, 30, 34]]);
  }));
  return _asyncMap.apply(this, arguments);
}

var asyncMap = /*#__PURE__*/asyncIterableCurry(__asyncMap);
exports.asyncMap = asyncMap;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],338:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__map);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

function __map(source, func) {
  var c, _iterator, _step, value;

  return _regeneratorRuntime.wrap(function __map$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          c = 0;
          _iterator = _createForOfIteratorHelper(source);
          _context.prev = 2;

          _iterator.s();

        case 4:
          if ((_step = _iterator.n()).done) {
            _context.next = 10;
            break;
          }

          value = _step.value;
          _context.next = 8;
          return func(value, c++);

        case 8:
          _context.next = 4;
          break;

        case 10:
          _context.next = 15;
          break;

        case 12:
          _context.prev = 12;
          _context.t0 = _context["catch"](2);

          _iterator.e(_context.t0);

        case 15:
          _context.prev = 15;

          _iterator.f();

          return _context.finish(15);

        case 18:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[2, 12, 15, 18]]);
}

exports.__map = __map;
var map = /*#__PURE__*/iterableCurry(__map);
exports.map = map;
},{"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],339:[function(require,module,exports){
var _require = require('../../internal/async-iterable.js'),
    asyncEnsureIterable = _require.asyncEnsureIterable;

var _require2 = require('../../internal/async-peekerator.js'),
    AsyncPeekerator = _require2.AsyncPeekerator;

function __asyncPeekerate(source) {
  return AsyncPeekerator.from(source);
}

exports.__asyncPeekerate = __asyncPeekerate;

function asyncWrapWithEnsureIterable(fn) {
  return function (source) {
    return fn(asyncEnsureIterable(source));
  };
}

var asyncPeekerate = asyncWrapWithEnsureIterable(__asyncPeekerate);
exports.asyncPeekerate = asyncPeekerate;
},{"../../internal/async-iterable.js":480,"../../internal/async-peekerator.js":483}],340:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    ensureIterable = _require.ensureIterable;

var _require2 = require('../../internal/peekerator.js'),
    Peekerator = _require2.Peekerator;

function __peekerate(source) {
  return Peekerator.from(source);
}

exports.__peekerate = __peekerate;

function wrapWithEnsureIterable(fn) {
  return function (source) {
    return fn(ensureIterable(source));
  };
}

var peekerate = wrapWithEnsureIterable(__peekerate);
exports.peekerate = peekerate;
},{"../../internal/iterable.js":493,"../../internal/peekerator.js":497}],341:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _asyncGeneratorDelegate = require("@babel/runtime/helpers/asyncGeneratorDelegate");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

function __asyncPrepend(_x, _x2) {
  return _asyncPrepend.apply(this, arguments);
}

exports.__asyncPrepend = __asyncPrepend;

function _asyncPrepend() {
  _asyncPrepend = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, value) {
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.next = 2;
            return value;

          case 2:
            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(source), _awaitAsyncGenerator), "t0", 3);

          case 3:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncPrepend.apply(this, arguments);
}

var asyncPrepend = /*#__PURE__*/asyncIterableCurry(__asyncPrepend);
exports.asyncPrepend = asyncPrepend;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncGeneratorDelegate":41,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],342:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__prepend);

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

function __prepend(source, value) {
  return _regeneratorRuntime.wrap(function __prepend$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          _context.next = 2;
          return value;

        case 2:
          return _context.delegateYield(source, "t0", 3);

        case 3:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

exports.__prepend = __prepend;
var prepend = /*#__PURE__*/iterableCurry(__prepend);
exports.prepend = prepend;
},{"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],343:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$peekerate/async-peekerate.js'),
    __asyncPeekerate = _require2.__asyncPeekerate;

function __asyncReduce(_x, _x2) {
  return _asyncReduce.apply(this, arguments);
}

function _asyncReduce() {
  _asyncReduce = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, reducer) {
    var initial,
        c,
        result,
        peekr,
        _args = arguments;
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            initial = _args.length > 2 && _args[2] !== undefined ? _args[2] : undefined;
            c = 0;
            result = initial;
            _context.next = 5;
            return __asyncPeekerate(iterable);

          case 5:
            peekr = _context.sent;
            _context.prev = 6;

            if (!(initial === undefined)) {
              _context.next = 14;
              break;
            }

            if (!peekr.done) {
              _context.next = 10;
              break;
            }

            throw new Error('Cannot reduce: no initial value specified and iterable was empty');

          case 10:
            result = peekr.value;
            _context.next = 13;
            return peekr.advance();

          case 13:
            c = 1;

          case 14:
            if (peekr.done) {
              _context.next = 22;
              break;
            }

            _context.next = 17;
            return reducer(result, peekr.value, c++);

          case 17:
            result = _context.sent;
            _context.next = 20;
            return peekr.advance();

          case 20:
            _context.next = 14;
            break;

          case 22:
            return _context.abrupt("return", result);

          case 23:
            _context.prev = 23;
            peekr["return"]();
            return _context.finish(23);

          case 26:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[6,, 23, 26]]);
  }));
  return _asyncReduce.apply(this, arguments);
}

exports.__asyncReduce = __asyncReduce;
var asyncReduce = /*#__PURE__*/asyncIterableCurry(__asyncReduce, {
  reduces: true,
  minArgs: 1,
  maxArgs: 2
});
exports.asyncReduce = asyncReduce;
},{"../$peekerate/async-peekerate.js":339,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],344:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$peekerate/peekerate.js'),
    __peekerate = _require2.__peekerate;

function __reduce(iterable, reducer) {
  var initial = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
  var c = 0;
  var result = initial;

  var peekr = __peekerate(iterable);

  try {
    if (initial === undefined) {
      if (peekr.done) {
        throw new Error('Cannot reduce: no initial value specified and iterable was empty');
      }

      result = peekr.value;
      peekr.advance();
      c = 1;
    }

    while (!peekr.done) {
      result = reducer(result, peekr.value, c++);
      peekr.advance();
    }

    return result;
  } finally {
    peekr["return"]();
  }
}

exports.__reduce = __reduce;
var reduce = /*#__PURE__*/iterableCurry(__reduce, {
  reduces: true,
  minArgs: 1,
  maxArgs: 2
});
exports.reduce = reduce;
},{"../$peekerate/peekerate.js":340,"../../internal/iterable.js":493}],345:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _asyncGeneratorDelegate = require("@babel/runtime/helpers/asyncGeneratorDelegate");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$to-array/async-to-array.js'),
    __asyncToArray = _require2.__asyncToArray;

function __asyncReverse(_x) {
  return _asyncReverse.apply(this, arguments);
}

exports.__asyncReverse = __asyncReverse;

function _asyncReverse() {
  _asyncReverse = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source) {
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.t0 = _asyncGeneratorDelegate;
            _context.t1 = _asyncIterator;
            _context.next = 4;
            return _awaitAsyncGenerator(__asyncToArray(source));

          case 4:
            _context.t2 = _context.sent.reverse();
            _context.t3 = (0, _context.t1)(_context.t2);
            _context.t4 = _awaitAsyncGenerator;
            return _context.delegateYield((0, _context.t0)(_context.t3, _context.t4), "t5", 8);

          case 8:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncReverse.apply(this, arguments);
}

var asyncReverse = /*#__PURE__*/asyncIterableCurry(__asyncReverse);
exports.asyncReverse = asyncReverse;
},{"../$to-array/async-to-array.js":398,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncGeneratorDelegate":41,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],346:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__reverse);

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$to-array/to-array.js'),
    __toArray = _require2.__toArray;

function __reverse(source) {
  return _regeneratorRuntime.wrap(function __reverse$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          return _context.delegateYield(__toArray(source).reverse(), "t0", 1);

        case 1:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

exports.__reverse = __reverse;
var reverse = /*#__PURE__*/iterableCurry(__reverse);
exports.reverse = reverse;
},{"../$to-array/to-array.js":399,"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],347:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$interleave/async-interleave.js'),
    __asyncInterleave = _require2.__asyncInterleave;

var _require3 = require('./internal/validate-args.js'),
    makeValidateArgs = _require3.makeValidateArgs;

function asyncByPosition(_x, _x2) {
  return _asyncByPosition.apply(this, arguments);
}

function _asyncByPosition() {
  _asyncByPosition = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref, all) {
    var start,
        step,
        _len,
        peekrs,
        _key,
        i,
        peekr,
        _args = arguments;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            start = _ref.start, step = _ref.step;

            for (_len = _args.length, peekrs = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
              peekrs[_key - 2] = _args[_key];
            }

            start = start % peekrs.length;
            i = start;

          case 4:
            if (all.done) {
              _context.next = 14;
              break;
            }

            peekr = peekrs[i];

            if (peekr.done) {
              _context.next = 11;
              break;
            }

            _context.next = 9;
            return peekr.value;

          case 9:
            _context.next = 11;
            return _awaitAsyncGenerator(peekr.advance());

          case 11:
            i = (i + step) % peekrs.length;
            _context.next = 4;
            break;

          case 14:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncByPosition.apply(this, arguments);
}

function __asyncRoundRobin(sources) {
  var step = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
  var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
  return __asyncInterleave(sources, asyncByPosition, {
    start: start,
    step: step
  });
}

exports.__asyncRoundRobin = __asyncRoundRobin;
var asyncRoundRobin = /*#__PURE__*/asyncIterableCurry(__asyncRoundRobin, {
  variadic: true,
  minArgs: 0,
  maxArgs: 2,
  validateArgs: /*#__PURE__*/makeValidateArgs('asyncRoundRobin')
});
exports.asyncRoundRobin = asyncRoundRobin;
},{"../$interleave/async-interleave.js":321,"../../internal/async-iterable.js":480,"./internal/validate-args.js":348,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],348:[function(require,module,exports){
var _require = require('../../../internal/number.js'),
    isInteger = _require.isInteger;

var _require2 = require('../../is-object/is-object.js'),
    isObject = _require2.isObject;

var _require3 = require('../../not-undefined/not-undefined.js'),
    notUndefined = _require3.notUndefined;

var makeValidateArgs = function makeValidateArgs(methodName) {
  return function validateArgs(args) {
    if (isObject(args[1])) {
      var _args$ = args[1],
          start = _args$.start,
          step = _args$.step;
      args[1] = start;
      args[2] = step;
    }

    if (notUndefined(args[2])) {
      args[2] = Number(args[2]);

      if (!isInteger(args[2], true)) {
        throw new Error("step argument to ".concat(methodName, " must be a non-zero integer"));
      }
    }
  };
};

exports.makeValidateArgs = makeValidateArgs;
},{"../../../internal/number.js":494,"../../is-object/is-object.js":440,"../../not-undefined/not-undefined.js":456}],349:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(byPosition);

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$interleave/interleave.js'),
    __interleave = _require2.__interleave;

var _require3 = require('./internal/validate-args.js'),
    makeValidateArgs = _require3.makeValidateArgs;

function byPosition(_ref, all) {
  var start,
      step,
      _len,
      peekrs,
      _key,
      i,
      peekr,
      _args = arguments;

  return _regeneratorRuntime.wrap(function byPosition$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          start = _ref.start, step = _ref.step;

          for (_len = _args.length, peekrs = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
            peekrs[_key - 2] = _args[_key];
          }

          start = start % peekrs.length;
          i = start;

        case 4:
          if (all.done) {
            _context.next = 13;
            break;
          }

          peekr = peekrs[i];

          if (peekr.done) {
            _context.next = 10;
            break;
          }

          _context.next = 9;
          return peekr.value;

        case 9:
          peekr.advance();

        case 10:
          i = (i + step) % peekrs.length;
          _context.next = 4;
          break;

        case 13:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

function __roundRobin(sources) {
  var step = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
  var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
  return __interleave(sources, byPosition, {
    start: start,
    step: step
  });
}

exports.__roundRobin = __roundRobin;
var roundRobin = /*#__PURE__*/iterableCurry(__roundRobin, {
  variadic: true,
  minArgs: 0,
  maxArgs: 2,
  validateArgs: /*#__PURE__*/makeValidateArgs('roundRobin')
});
exports.roundRobin = roundRobin;
},{"../$interleave/interleave.js":322,"../../internal/iterable.js":493,"./internal/validate-args.js":348,"@babel/runtime/regenerator":65}],350:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncEnsureIterable = _require.asyncEnsureIterable;

function __asyncSize(_x) {
  return _asyncSize.apply(this, arguments);
}

function _asyncSize() {
  _asyncSize = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable) {
    var iter, size, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, _;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            iter = asyncEnsureIterable(iterable);
            size = 0;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 4;
            _iterator = _asyncIterator(iter);

          case 6:
            _context.next = 8;
            return _iterator.next();

          case 8:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 12;
            return _step.value;

          case 12:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 19;
              break;
            }

            _ = _value;
            size++;

          case 16:
            _iteratorNormalCompletion = true;
            _context.next = 6;
            break;

          case 19:
            _context.next = 25;
            break;

          case 21:
            _context.prev = 21;
            _context.t0 = _context["catch"](4);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 25:
            _context.prev = 25;
            _context.prev = 26;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 30;
              break;
            }

            _context.next = 30;
            return _iterator["return"]();

          case 30:
            _context.prev = 30;

            if (!_didIteratorError) {
              _context.next = 33;
              break;
            }

            throw _iteratorError;

          case 33:
            return _context.finish(30);

          case 34:
            return _context.finish(25);

          case 35:
            return _context.abrupt("return", size);

          case 36:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[4, 21, 25, 35], [26,, 30, 34]]);
  }));
  return _asyncSize.apply(this, arguments);
}

exports.__asyncSize = __asyncSize;
var asyncSize = __asyncSize;
exports.asyncSize = asyncSize;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],351:[function(require,module,exports){
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    ensureIterable = _require.ensureIterable;

function __size(iterable) {
  var iter = ensureIterable(iterable);
  var size = 0;

  var _iterator = _createForOfIteratorHelper(iter),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var _ = _step.value;
      size++;
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

  return size;
}

exports.__size = __size;
var size = __size;
exports.size = size;
},{"../../internal/iterable.js":493}],352:[function(require,module,exports){
var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncGeneratorDelegate = require("@babel/runtime/helpers/asyncGeneratorDelegate");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/circular-buffer.js'),
    CircularBuffer = _require.CircularBuffer;

var _require2 = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require2.asyncIterableCurry;

var _require3 = require('./internal/validate-args.js'),
    makeValidateArgs = _require3.makeValidateArgs;

function __asyncSliceFromStart(_x) {
  return _asyncSliceFromStart.apply(this, arguments);
}

exports.__asyncSliceFromStart = __asyncSliceFromStart;

function _asyncSliceFromStart() {
  _asyncSliceFromStart = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source) {
    var start,
        end,
        step,
        currentPos,
        nextValidPos,
        bufferSize,
        buffer,
        counter,
        _iteratorNormalCompletion,
        _didIteratorError,
        _iteratorError,
        _iterator,
        _step,
        _value,
        value,
        _args = arguments;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            start = _args.length > 1 && _args[1] !== undefined ? _args[1] : 0;
            end = _args.length > 2 && _args[2] !== undefined ? _args[2] : Infinity;
            step = _args.length > 3 && _args[3] !== undefined ? _args[3] : 1;
            currentPos = 0;
            nextValidPos = start;
            bufferSize = Math.abs(end);
            counter = 0;

            if (end < 0) {
              buffer = new CircularBuffer(bufferSize);
            }

            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 10;
            _iterator = _asyncIterator(source);

          case 12:
            _context.next = 14;
            return _awaitAsyncGenerator(_iterator.next());

          case 14:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 18;
            return _awaitAsyncGenerator(_step.value);

          case 18:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 36;
              break;
            }

            value = _value;

            if (!buffer) {
              _context.next = 26;
              break;
            }

            value = buffer.push(value);
            counter++;

            if (!(counter <= bufferSize)) {
              _context.next = 26;
              break;
            }

            return _context.abrupt("continue", 33);

          case 26:
            if (!(currentPos >= end && end >= 0)) {
              _context.next = 28;
              break;
            }

            return _context.abrupt("break", 36);

          case 28:
            if (!(nextValidPos === currentPos)) {
              _context.next = 32;
              break;
            }

            _context.next = 31;
            return value;

          case 31:
            nextValidPos += step;

          case 32:
            currentPos++;

          case 33:
            _iteratorNormalCompletion = true;
            _context.next = 12;
            break;

          case 36:
            _context.next = 42;
            break;

          case 38:
            _context.prev = 38;
            _context.t0 = _context["catch"](10);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 42:
            _context.prev = 42;
            _context.prev = 43;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 47;
              break;
            }

            _context.next = 47;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 47:
            _context.prev = 47;

            if (!_didIteratorError) {
              _context.next = 50;
              break;
            }

            throw _iteratorError;

          case 50:
            return _context.finish(47);

          case 51:
            return _context.finish(42);

          case 52:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[10, 38, 42, 52], [43,, 47, 51]]);
  }));
  return _asyncSliceFromStart.apply(this, arguments);
}

function asyncBufferedSlice(_x3, _x4, _x5, _x6) {
  return _asyncBufferedSlice.apply(this, arguments);
}

function _asyncBufferedSlice() {
  _asyncBufferedSlice = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(source, start, end, step) {
    var bufferSize, buffer, counter, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, _value2, value, newEnd;

    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            bufferSize = Math.abs(start);
            buffer = new CircularBuffer(bufferSize);
            counter = 0;
            _iteratorNormalCompletion2 = true;
            _didIteratorError2 = false;
            _context3.prev = 5;
            _iterator2 = _asyncIterator(source);

          case 7:
            _context3.next = 9;
            return _iterator2.next();

          case 9:
            _step2 = _context3.sent;
            _iteratorNormalCompletion2 = _step2.done;
            _context3.next = 13;
            return _step2.value;

          case 13:
            _value2 = _context3.sent;

            if (_iteratorNormalCompletion2) {
              _context3.next = 21;
              break;
            }

            value = _value2;
            buffer.push(value);
            counter++;

          case 18:
            _iteratorNormalCompletion2 = true;
            _context3.next = 7;
            break;

          case 21:
            _context3.next = 27;
            break;

          case 23:
            _context3.prev = 23;
            _context3.t0 = _context3["catch"](5);
            _didIteratorError2 = true;
            _iteratorError2 = _context3.t0;

          case 27:
            _context3.prev = 27;
            _context3.prev = 28;

            if (!(!_iteratorNormalCompletion2 && _iterator2["return"] != null)) {
              _context3.next = 32;
              break;
            }

            _context3.next = 32;
            return _iterator2["return"]();

          case 32:
            _context3.prev = 32;

            if (!_didIteratorError2) {
              _context3.next = 35;
              break;
            }

            throw _iteratorError2;

          case 35:
            return _context3.finish(32);

          case 36:
            return _context3.finish(27);

          case 37:
            if (!(isFinite(end) && end > 0)) {
              _context3.next = 43;
              break;
            }

            newEnd = end - (counter - buffer.size);

            if (!(newEnd < 0)) {
              _context3.next = 41;
              break;
            }

            return _context3.abrupt("return", []);

          case 41:
            _context3.next = 44;
            break;

          case 43:
            newEnd = end;

          case 44:
            return _context3.abrupt("return", __asyncSliceFromStart(buffer, 0, newEnd, step));

          case 45:
          case "end":
            return _context3.stop();
        }
      }
    }, _callee3, null, [[5, 23, 27, 37], [28,, 32, 36]]);
  }));
  return _asyncBufferedSlice.apply(this, arguments);
}

function __asyncSlice(_x2) {
  return _asyncSlice.apply(this, arguments);
}

exports.__asyncSlice = __asyncSlice;

function _asyncSlice() {
  _asyncSlice = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(source) {
    var start,
        end,
        step,
        _args2 = arguments;
    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            start = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : 0;
            end = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : Infinity;
            step = _args2.length > 3 && _args2[3] !== undefined ? _args2[3] : 1;

            if (!(start >= 0)) {
              _context2.next = 7;
              break;
            }

            return _context2.delegateYield(_asyncGeneratorDelegate(_asyncIterator(__asyncSliceFromStart(source, start, end, step)), _awaitAsyncGenerator), "t0", 5);

          case 5:
            _context2.next = 15;
            break;

          case 7:
            _context2.t1 = _asyncGeneratorDelegate;
            _context2.t2 = _asyncIterator;
            _context2.next = 11;
            return _awaitAsyncGenerator(asyncBufferedSlice(source, start, end, step));

          case 11:
            _context2.t3 = _context2.sent;
            _context2.t4 = (0, _context2.t2)(_context2.t3);
            _context2.t5 = _awaitAsyncGenerator;
            return _context2.delegateYield((0, _context2.t1)(_context2.t4, _context2.t5), "t6", 15);

          case 15:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2);
  }));
  return _asyncSlice.apply(this, arguments);
}

var asyncSlice = /*#__PURE__*/asyncIterableCurry(__asyncSlice, {
  validateArgs: /*#__PURE__*/makeValidateArgs('asyncSlice'),
  growRight: true,
  minArgs: 0,
  maxArgs: 3
});
exports.asyncSlice = asyncSlice;
},{"../../internal/async-iterable.js":480,"../../internal/circular-buffer.js":486,"./internal/validate-args.js":353,"@babel/runtime/helpers/asyncGeneratorDelegate":41,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],353:[function(require,module,exports){
var _slicedToArray = require("@babel/runtime/helpers/slicedToArray");

var _require = require('../../../internal/number.js'),
    isInteger = _require.isInteger,
    isPositiveInteger = _require.isPositiveInteger,
    isIntegerOrInfinite = _require.isIntegerOrInfinite;

var _require2 = require('../../is-object/is-object.js'),
    isObject = _require2.isObject;

var makeValidateArgs = function makeValidateArgs(methodName) {
  return function validateArgs(args) {
    var _args = _slicedToArray(args, 4),
        _args$ = _args[1],
        optsOrStart = _args$ === void 0 ? 0 : _args$,
        _args$2 = _args[2],
        end = _args$2 === void 0 ? Infinity : _args$2,
        _args$3 = _args[3],
        step = _args$3 === void 0 ? 1 : _args$3;

    var start = typeof optsOrStart === 'number' ? optsOrStart : undefined;

    if (isObject(optsOrStart)) {
      var _optsOrStart$start = optsOrStart.start;
      start = _optsOrStart$start === void 0 ? 0 : _optsOrStart$start;
      var _optsOrStart$end = optsOrStart.end;
      end = _optsOrStart$end === void 0 ? Infinity : _optsOrStart$end;
      var _optsOrStart$step = optsOrStart.step;
      step = _optsOrStart$step === void 0 ? 1 : _optsOrStart$step;
    }

    if (!isInteger(start)) {
      throw new TypeError("start argument to ".concat(methodName, " must be a number"));
    }

    if (!isIntegerOrInfinite(end)) {
      throw new TypeError("end argument to ".concat(methodName, " must be an integer or infinte"));
    }

    if (!isPositiveInteger(step)) {
      throw new TypeError("step argument to ".concat(methodName, " must be a integer > 0"));
    }

    args[1] = start;
    args[2] = end;
    args[3] = step;
  };
};

exports.makeValidateArgs = makeValidateArgs;
},{"../../../internal/number.js":494,"../../is-object/is-object.js":440,"@babel/runtime/helpers/slicedToArray":59}],354:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__sliceFromStart),
    _marked2 = /*#__PURE__*/_regeneratorRuntime.mark(__slice);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/circular-buffer.js'),
    CircularBuffer = _require.CircularBuffer;

var _require2 = require('../../internal/iterable.js'),
    iterableCurry = _require2.iterableCurry;

var _require3 = require('./internal/validate-args.js'),
    makeValidateArgs = _require3.makeValidateArgs;

function __sliceFromStart(source) {
  var start,
      end,
      step,
      currentPos,
      nextValidPos,
      bufferSize,
      buffer,
      counter,
      _iterator2,
      _step2,
      value,
      _args = arguments;

  return _regeneratorRuntime.wrap(function __sliceFromStart$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          start = _args.length > 1 && _args[1] !== undefined ? _args[1] : 0;
          end = _args.length > 2 && _args[2] !== undefined ? _args[2] : Infinity;
          step = _args.length > 3 && _args[3] !== undefined ? _args[3] : 1;
          currentPos = 0;
          nextValidPos = start;
          bufferSize = Math.abs(end);
          counter = 0;

          if (end < 0) {
            buffer = new CircularBuffer(bufferSize);
          }

          _iterator2 = _createForOfIteratorHelper(source);
          _context.prev = 9;

          _iterator2.s();

        case 11:
          if ((_step2 = _iterator2.n()).done) {
            _context.next = 27;
            break;
          }

          value = _step2.value;

          if (!buffer) {
            _context.next = 18;
            break;
          }

          value = buffer.push(value);
          counter++;

          if (!(counter <= bufferSize)) {
            _context.next = 18;
            break;
          }

          return _context.abrupt("continue", 25);

        case 18:
          if (!(currentPos >= end && end >= 0)) {
            _context.next = 20;
            break;
          }

          return _context.abrupt("break", 27);

        case 20:
          if (!(nextValidPos === currentPos)) {
            _context.next = 24;
            break;
          }

          _context.next = 23;
          return value;

        case 23:
          nextValidPos += step;

        case 24:
          currentPos++;

        case 25:
          _context.next = 11;
          break;

        case 27:
          _context.next = 32;
          break;

        case 29:
          _context.prev = 29;
          _context.t0 = _context["catch"](9);

          _iterator2.e(_context.t0);

        case 32:
          _context.prev = 32;

          _iterator2.f();

          return _context.finish(32);

        case 35:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[9, 29, 32, 35]]);
}

exports.__sliceFromStart = __sliceFromStart;

function bufferedSlice(source, start, end, step) {
  var bufferSize = Math.abs(start);
  var buffer = new CircularBuffer(bufferSize);
  var counter = 0;

  var _iterator = _createForOfIteratorHelper(source),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var value = _step.value;
      buffer.push(value);
      counter++;
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

  var newEnd;

  if (isFinite(end) && end > 0) {
    newEnd = end - (counter - buffer.size);
    if (newEnd < 0) return [];
  } else {
    newEnd = end;
  }

  return __sliceFromStart(buffer, 0, newEnd, step);
}

function __slice(source) {
  var start,
      end,
      step,
      _args2 = arguments;
  return _regeneratorRuntime.wrap(function __slice$(_context2) {
    while (1) {
      switch (_context2.prev = _context2.next) {
        case 0:
          start = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : 0;
          end = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : Infinity;
          step = _args2.length > 3 && _args2[3] !== undefined ? _args2[3] : 1;

          if (!(start >= 0)) {
            _context2.next = 7;
            break;
          }

          return _context2.delegateYield(__sliceFromStart(source, start, end, step), "t0", 5);

        case 5:
          _context2.next = 8;
          break;

        case 7:
          return _context2.delegateYield(bufferedSlice(source, start, end, step), "t1", 8);

        case 8:
        case "end":
          return _context2.stop();
      }
    }
  }, _marked2);
}

exports.__slice = __slice;
var slice = /*#__PURE__*/iterableCurry(__slice, {
  validateArgs: /*#__PURE__*/makeValidateArgs('slice'),
  growRight: true,
  minArgs: 0,
  maxArgs: 3
});
exports.slice = slice;
},{"../../internal/circular-buffer.js":486,"../../internal/iterable.js":493,"./internal/validate-args.js":353,"@babel/runtime/regenerator":65}],355:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

function __asyncSome(_x, _x2) {
  return _asyncSome.apply(this, arguments);
}

function _asyncSome() {
  _asyncSome = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, func) {
    var c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            c = 0;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 3;
            _iterator = _asyncIterator(iterable);

          case 5:
            _context.next = 7;
            return _iterator.next();

          case 7:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 11;
            return _step.value;

          case 11:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 21;
              break;
            }

            value = _value;
            _context.next = 16;
            return func(value, c++);

          case 16:
            if (!_context.sent) {
              _context.next = 18;
              break;
            }

            return _context.abrupt("return", true);

          case 18:
            _iteratorNormalCompletion = true;
            _context.next = 5;
            break;

          case 21:
            _context.next = 27;
            break;

          case 23:
            _context.prev = 23;
            _context.t0 = _context["catch"](3);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 27:
            _context.prev = 27;
            _context.prev = 28;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 32;
              break;
            }

            _context.next = 32;
            return _iterator["return"]();

          case 32:
            _context.prev = 32;

            if (!_didIteratorError) {
              _context.next = 35;
              break;
            }

            throw _iteratorError;

          case 35:
            return _context.finish(32);

          case 36:
            return _context.finish(27);

          case 37:
            return _context.abrupt("return", false);

          case 38:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[3, 23, 27, 37], [28,, 32, 36]]);
  }));
  return _asyncSome.apply(this, arguments);
}

exports.__asyncSome = __asyncSome;
var asyncSome = /*#__PURE__*/asyncIterableCurry(__asyncSome, {
  reduces: true
});
exports.asyncSome = asyncSome;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],356:[function(require,module,exports){
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

function __some(iterable, func) {
  var c = 0;

  var _iterator = _createForOfIteratorHelper(iterable),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var value = _step.value;

      if (func(value, c++)) {
        return true;
      }
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

  return false;
}

exports.__some = __some;
var some = /*#__PURE__*/iterableCurry(__some, {
  reduces: true
});
exports.some = some;
},{"../../internal/iterable.js":493}],357:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$spliterate-grouped/async-spliterate-grouped.js'),
    __asyncSpliterateGrouped = _require2.__asyncSpliterateGrouped;

var _require3 = require('../$peekerate/async-peekerate.js'),
    __asyncPeekerate = _require3.__asyncPeekerate;

var initialKey = Symbol('initial group key');

function asyncGroupingSpliterator(_x, _x2, _x3) {
  return _asyncGroupingSpliterator.apply(this, arguments);
}

function _asyncGroupingSpliterator() {
  _asyncGroupingSpliterator = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(split, _ref, source) {
    var getKey, peekr, key, idx, lastKey;
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            getKey = _ref.getKey;
            _context.next = 3;
            return _awaitAsyncGenerator(__asyncPeekerate(source));

          case 3:
            peekr = _context.sent;
            key = initialKey;
            idx = 0;

          case 6:
            if (peekr.done) {
              _context.next = 22;
              break;
            }

            lastKey = key;
            _context.next = 10;
            return _awaitAsyncGenerator(getKey(peekr.value, idx++));

          case 10:
            key = _context.sent;

            if (!(lastKey !== key)) {
              _context.next = 16;
              break;
            }

            _context.next = 14;
            return split;

          case 14:
            _context.next = 16;
            return key;

          case 16:
            _context.next = 18;
            return peekr.value;

          case 18:
            _context.next = 20;
            return _awaitAsyncGenerator(peekr.advance());

          case 20:
            _context.next = 6;
            break;

          case 22:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncGroupingSpliterator.apply(this, arguments);
}

function __asyncSplitGroups(source) {
  var getKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (value) {
    return value;
  };
  return __asyncSpliterateGrouped(source, asyncGroupingSpliterator, {
    getKey: getKey
  });
}

exports.__asyncSplitGroups = __asyncSplitGroups;
var asyncSplitGroups = /*#__PURE__*/asyncIterableCurry(__asyncSplitGroups, {
  minArgs: 0,
  maxArgs: 1
});
exports.asyncSplitGroups = asyncSplitGroups;
},{"../$peekerate/async-peekerate.js":339,"../$spliterate-grouped/async-spliterate-grouped.js":371,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],358:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(groupingSpliterator);

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$spliterate-grouped/spliterate-grouped.js'),
    __spliterateGrouped = _require2.__spliterateGrouped;

var _require3 = require('../$peekerate/peekerate.js'),
    __peekerate = _require3.__peekerate;

var initialKey = Symbol('initial group key');

function groupingSpliterator(split, _ref, source) {
  var getKey, peekr, key, idx, lastKey;
  return _regeneratorRuntime.wrap(function groupingSpliterator$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          getKey = _ref.getKey;
          peekr = __peekerate(source);
          key = initialKey;
          idx = 0;

        case 4:
          if (peekr.done) {
            _context.next = 17;
            break;
          }

          lastKey = key;
          key = getKey(peekr.value, idx++);

          if (!(lastKey !== key)) {
            _context.next = 12;
            break;
          }

          _context.next = 10;
          return split;

        case 10:
          _context.next = 12;
          return key;

        case 12:
          _context.next = 14;
          return peekr.value;

        case 14:
          peekr.advance();
          _context.next = 4;
          break;

        case 17:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

function __splitGroups(source) {
  var getKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (value) {
    return value;
  };
  return __spliterateGrouped(source, groupingSpliterator, {
    getKey: getKey
  });
}

exports.__splitGroups = __splitGroups;
var splitGroups = /*#__PURE__*/iterableCurry(__splitGroups, {
  minArgs: 0,
  maxArgs: 1
});
exports.splitGroups = splitGroups;
},{"../$peekerate/peekerate.js":340,"../$spliterate-grouped/spliterate-grouped.js":372,"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],359:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _asyncGeneratorDelegate = require("@babel/runtime/helpers/asyncGeneratorDelegate");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../../internal/async-any-seq.js'),
    asyncSeqsToArray = _require2.asyncSeqsToArray;

var _require3 = require('../$starts-with-seq/starts-with-seq.js'),
    __startsWithSeq = _require3.__startsWithSeq;

var _require4 = require('../$window-ahead/async-window-ahead.js'),
    __asyncWindowAhead = _require4.__asyncWindowAhead;

var _require5 = require('../$spliterate/async-spliterate.js'),
    __asyncSpliterate = _require5.__asyncSpliterate;

function getMatchingLength(buffer, separatorSeqs, same) {
  var _iterator2 = _createForOfIteratorHelper(separatorSeqs),
      _step2;

  try {
    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
      var subsequence = _step2.value;

      if (__startsWithSeq(buffer, subsequence, same)) {
        return subsequence.length;
      }
    }
  } catch (err) {
    _iterator2.e(err);
  } finally {
    _iterator2.f();
  }

  return 0;
}

function asyncAnySeqspliterator(_x, _x2, _x3) {
  return _asyncAnySeqspliterator.apply(this, arguments);
}

function _asyncAnySeqspliterator() {
  _asyncAnySeqspliterator = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(split, _ref, source) {
    var separatorSeqs, same, maxMatchLength, skip, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, buffer, matchingLength;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            separatorSeqs = _ref.separatorSeqs, same = _ref.same;
            maxMatchLength = separatorSeqs.reduce(function (max, _ref2) {
              var length = _ref2.length;
              return Math.max(max, length);
            }, 1);
            skip = 0;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 5;
            _iterator = _asyncIterator(__asyncWindowAhead(source, maxMatchLength, {
              useFiller: false
            }));

          case 7:
            _context.next = 9;
            return _awaitAsyncGenerator(_iterator.next());

          case 9:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 13;
            return _awaitAsyncGenerator(_step.value);

          case 13:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 31;
              break;
            }

            buffer = _value;

            if (!(skip > 0)) {
              _context.next = 19;
              break;
            }

            skip--;
            return _context.abrupt("continue", 28);

          case 19:
            matchingLength = getMatchingLength(buffer, separatorSeqs, same);

            if (!(matchingLength > 0)) {
              _context.next = 26;
              break;
            }

            _context.next = 23;
            return split;

          case 23:
            skip = matchingLength - 1;
            _context.next = 28;
            break;

          case 26:
            _context.next = 28;
            return buffer.get(0);

          case 28:
            _iteratorNormalCompletion = true;
            _context.next = 7;
            break;

          case 31:
            _context.next = 37;
            break;

          case 33:
            _context.prev = 33;
            _context.t0 = _context["catch"](5);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 37:
            _context.prev = 37;
            _context.prev = 38;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 42;
              break;
            }

            _context.next = 42;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 42:
            _context.prev = 42;

            if (!_didIteratorError) {
              _context.next = 45;
              break;
            }

            throw _iteratorError;

          case 45:
            return _context.finish(42);

          case 46:
            return _context.finish(37);

          case 47:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[5, 33, 37, 47], [38,, 42, 46]]);
  }));
  return _asyncAnySeqspliterator.apply(this, arguments);
}

function __asyncSplitOnAnySeq(_x4, _x5) {
  return _asyncSplitOnAnySeq.apply(this, arguments);
}

exports.__asyncSplitOnAnySeq = __asyncSplitOnAnySeq;

function _asyncSplitOnAnySeq() {
  _asyncSplitOnAnySeq = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(source, separatorSeqs) {
    var same,
        separatorSeqsArr,
        _args2 = arguments;
    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            same = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : Object.is;
            _context2.next = 3;
            return _awaitAsyncGenerator(asyncSeqsToArray(separatorSeqs));

          case 3:
            separatorSeqsArr = _context2.sent.filter(function (s) {
              return s.length > 0;
            });
            return _context2.delegateYield(_asyncGeneratorDelegate(_asyncIterator(__asyncSpliterate(source, asyncAnySeqspliterator, {
              separatorSeqs: separatorSeqsArr.sort(function (a, b) {
                return b.length - a.length;
              }),
              same: same
            })), _awaitAsyncGenerator), "t0", 5);

          case 5:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2);
  }));
  return _asyncSplitOnAnySeq.apply(this, arguments);
}

var asyncSplitOnAnySeq = /*#__PURE__*/asyncIterableCurry(__asyncSplitOnAnySeq, {
  minArgs: 1,
  maxArgs: 2
});
exports.asyncSplitOnAnySeq = asyncSplitOnAnySeq;
},{"../$spliterate/async-spliterate.js":373,"../$starts-with-seq/starts-with-seq.js":380,"../$window-ahead/async-window-ahead.js":402,"../../internal/async-any-seq.js":475,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncGeneratorDelegate":41,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],360:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(anySeqspliterator),
    _marked2 = /*#__PURE__*/_regeneratorRuntime.mark(__splitOnAnySeq);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../../internal/any-seq.js'),
    seqsToArray = _require2.seqsToArray;

var _require3 = require('../$starts-with-seq/starts-with-seq.js'),
    __startsWithSeq = _require3.__startsWithSeq;

var _require4 = require('../$window-ahead/window-ahead.js'),
    __windowAhead = _require4.__windowAhead;

var _require5 = require('../$spliterate/spliterate.js'),
    __spliterate = _require5.__spliterate;

function getMatchingLength(buffer, separatorSeqs, same) {
  var _iterator = _createForOfIteratorHelper(separatorSeqs),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var subsequence = _step.value;

      if (__startsWithSeq(buffer, subsequence, same)) {
        return subsequence.length;
      }
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

  return 0;
}

function anySeqspliterator(split, _ref, source) {
  var separatorSeqs, same, maxMatchLength, skip, _iterator2, _step2, buffer, matchingLength;

  return _regeneratorRuntime.wrap(function anySeqspliterator$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          separatorSeqs = _ref.separatorSeqs, same = _ref.same;
          maxMatchLength = separatorSeqs.reduce(function (max, _ref2) {
            var length = _ref2.length;
            return Math.max(max, length);
          }, 1);
          skip = 0;
          _iterator2 = _createForOfIteratorHelper(__windowAhead(source, maxMatchLength, {
            useFiller: false
          }));
          _context.prev = 4;

          _iterator2.s();

        case 6:
          if ((_step2 = _iterator2.n()).done) {
            _context.next = 22;
            break;
          }

          buffer = _step2.value;

          if (!(skip > 0)) {
            _context.next = 11;
            break;
          }

          skip--;
          return _context.abrupt("continue", 20);

        case 11:
          matchingLength = getMatchingLength(buffer, separatorSeqs, same);

          if (!(matchingLength > 0)) {
            _context.next = 18;
            break;
          }

          _context.next = 15;
          return split;

        case 15:
          skip = matchingLength - 1;
          _context.next = 20;
          break;

        case 18:
          _context.next = 20;
          return buffer.get(0);

        case 20:
          _context.next = 6;
          break;

        case 22:
          _context.next = 27;
          break;

        case 24:
          _context.prev = 24;
          _context.t0 = _context["catch"](4);

          _iterator2.e(_context.t0);

        case 27:
          _context.prev = 27;

          _iterator2.f();

          return _context.finish(27);

        case 30:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[4, 24, 27, 30]]);
}

function __splitOnAnySeq(source, separatorSeqs) {
  var same,
      separatorSeqsArr,
      _args2 = arguments;
  return _regeneratorRuntime.wrap(function __splitOnAnySeq$(_context2) {
    while (1) {
      switch (_context2.prev = _context2.next) {
        case 0:
          same = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : Object.is;
          separatorSeqsArr = seqsToArray(separatorSeqs).filter(function (s) {
            return s.length > 0;
          });
          return _context2.delegateYield(__spliterate(source, anySeqspliterator, {
            separatorSeqs: separatorSeqsArr.sort(function (a, b) {
              return b.length - a.length;
            }),
            same: same
          }), "t0", 3);

        case 3:
        case "end":
          return _context2.stop();
      }
    }
  }, _marked2);
}

exports.__splitOnAnySeq = __splitOnAnySeq;
var splitOnAnySeq = /*#__PURE__*/iterableCurry(__splitOnAnySeq, {
  minArgs: 1,
  maxArgs: 2
});
exports.splitOnAnySeq = splitOnAnySeq;
},{"../$spliterate/spliterate.js":374,"../$starts-with-seq/starts-with-seq.js":380,"../$window-ahead/window-ahead.js":403,"../../internal/any-seq.js":474,"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],361:[function(require,module,exports){
var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$split-when/async-split-when.js'),
    __asyncSplitWhen = _require2.__asyncSplitWhen;

var _require3 = require('../$includes/includes.js'),
    __includes = _require3.__includes;

function __asyncSplitOnAny(source, separators) {
  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;
  return __asyncSplitWhen(source, function (value) {
    return __includes(separators, value, function (a, b) {
      return same(b, a);
    });
  });
}

exports.__asyncSplitOnAny = __asyncSplitOnAny;
var asyncSplitOnAny = /*#__PURE__*/asyncIterableCurry(__asyncSplitOnAny, {
  minArgs: 1,
  maxArgs: 2,
  validateArgs: function validateArgs(args) {}
});
exports.asyncSplitOnAny = asyncSplitOnAny;
},{"../$includes/includes.js":320,"../$split-when/async-split-when.js":367,"../../internal/async-iterable.js":480}],362:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$split-when/split-when.js'),
    __splitWhen = _require2.__splitWhen;

var _require3 = require('../$includes/includes.js'),
    __includes = _require3.__includes;

function __splitOnAny(source, separators) {
  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;
  return __splitWhen(source, function (value) {
    return __includes(separators, value, function (a, b) {
      return same(b, a);
    });
  });
}

exports.__splitOnAny = __splitOnAny;
var splitOnAny = /*#__PURE__*/iterableCurry(__splitOnAny, {
  minArgs: 1,
  maxArgs: 2,
  validateArgs: function validateArgs(args) {
    if (true && typeof args[0] === 'string') {
      console.warn("For string inputs use splitOnAnySeq instead of splitOnAny");
    }
  }
});
exports.splitOnAny = splitOnAny;
},{"../$includes/includes.js":320,"../$split-when/split-when.js":368,"../../internal/iterable.js":493}],363:[function(require,module,exports){
var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry,
    asyncEnsureIterable = _require.asyncEnsureIterable;

var _require2 = require('../$split-on-any-seq/async-split-on-any-seq.js'),
    __asyncSplitOnAnySeq = _require2.__asyncSplitOnAnySeq;

function __asyncSplitOnSeq(source, separatorSeq) {
  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;
  return __asyncSplitOnAnySeq(source, [separatorSeq], same);
}

exports.__asyncSplitOnSeq = __asyncSplitOnSeq;
var asyncSplitOnSeq = /*#__PURE__*/asyncIterableCurry(__asyncSplitOnSeq, {
  minArgs: 1,
  maxArgs: 2,
  validateArgs: function validateArgs(args) {
    args[1] = asyncEnsureIterable(args[1]);
  }
});
exports.asyncSplitOnSeq = asyncSplitOnSeq;
},{"../$split-on-any-seq/async-split-on-any-seq.js":359,"../../internal/async-iterable.js":480}],364:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry,
    ensureIterable = _require.ensureIterable;

var _require2 = require('../$split-on-any-seq/split-on-any-seq.js'),
    __splitOnAnySeq = _require2.__splitOnAnySeq;

function __splitOnSeq(source, separatorSeq) {
  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;
  return __splitOnAnySeq(source, [separatorSeq], same);
}

exports.__splitOnSeq = __splitOnSeq;
var splitOnSeq = /*#__PURE__*/iterableCurry(__splitOnSeq, {
  minArgs: 1,
  maxArgs: 2,
  validateArgs: function validateArgs(args) {
    args[1] = ensureIterable(args[1]);
  }
});
exports.splitOnSeq = splitOnSeq;
},{"../$split-on-any-seq/split-on-any-seq.js":360,"../../internal/iterable.js":493}],365:[function(require,module,exports){
var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$split-when/async-split-when.js'),
    __asyncSplitWhen = _require2.__asyncSplitWhen;

function __asyncSplitOn(source, separator) {
  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;
  return __asyncSplitWhen(source, function (value) {
    return same(separator, value);
  });
}

exports.__asyncSplitOn = __asyncSplitOn;
var asyncSplitOn = /*#__PURE__*/asyncIterableCurry(__asyncSplitOn, {
  minArgs: 1,
  maxArgs: 2,
  validateArgs: function validateArgs(args) {}
});
exports.asyncSplitOn = asyncSplitOn;
},{"../$split-when/async-split-when.js":367,"../../internal/async-iterable.js":480}],366:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$split-when/split-when.js'),
    __splitWhen = _require2.__splitWhen;

function __splitOn(source, separator) {
  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;
  return __splitWhen(source, function (value) {
    return same(separator, value);
  });
}

exports.__splitOn = __splitOn;
var splitOn = /*#__PURE__*/iterableCurry(__splitOn, {
  minArgs: 1,
  maxArgs: 2,
  validateArgs: function validateArgs(args) {
    if (true && typeof args[0] === 'string') {
      console.warn("For string inputs use splitOnSeq instead of splitOn");
    }
  }
});
exports.splitOn = splitOn;
},{"../$split-when/split-when.js":368,"../../internal/iterable.js":493}],367:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$spliterate/async-spliterate.js'),
    __asyncSpliterate = _require2.__asyncSpliterate;

function asyncPredicateSpliterator(_x, _x2, _x3) {
  return _asyncPredicateSpliterator.apply(this, arguments);
}

function _asyncPredicateSpliterator() {
  _asyncPredicateSpliterator = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(split, _ref, source) {
    var predicate, i, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            predicate = _ref.predicate;
            i = 0;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 4;
            _iterator = _asyncIterator(source);

          case 6:
            _context.next = 8;
            return _awaitAsyncGenerator(_iterator.next());

          case 8:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 12;
            return _awaitAsyncGenerator(_step.value);

          case 12:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 27;
              break;
            }

            value = _value;
            _context.next = 17;
            return _awaitAsyncGenerator(predicate(value, i++));

          case 17:
            if (!_context.sent) {
              _context.next = 21;
              break;
            }

            _context.t0 = split;
            _context.next = 22;
            break;

          case 21:
            _context.t0 = value;

          case 22:
            _context.next = 24;
            return _context.t0;

          case 24:
            _iteratorNormalCompletion = true;
            _context.next = 6;
            break;

          case 27:
            _context.next = 33;
            break;

          case 29:
            _context.prev = 29;
            _context.t1 = _context["catch"](4);
            _didIteratorError = true;
            _iteratorError = _context.t1;

          case 33:
            _context.prev = 33;
            _context.prev = 34;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 38;
              break;
            }

            _context.next = 38;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 38:
            _context.prev = 38;

            if (!_didIteratorError) {
              _context.next = 41;
              break;
            }

            throw _iteratorError;

          case 41:
            return _context.finish(38);

          case 42:
            return _context.finish(33);

          case 43:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[4, 29, 33, 43], [34,, 38, 42]]);
  }));
  return _asyncPredicateSpliterator.apply(this, arguments);
}

function __asyncSplitWhen(source, predicate) {
  return __asyncSpliterate(source, asyncPredicateSpliterator, {
    predicate: predicate
  });
}

exports.__asyncSplitWhen = __asyncSplitWhen;
var asyncSplitWhen = /*#__PURE__*/asyncIterableCurry(__asyncSplitWhen);
exports.asyncSplitWhen = asyncSplitWhen;
},{"../$spliterate/async-spliterate.js":373,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],368:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(predicateSpliterator);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$spliterate/spliterate.js'),
    __spliterate = _require2.__spliterate;

function predicateSpliterator(split, _ref, source) {
  var predicate, i, _iterator, _step, value;

  return _regeneratorRuntime.wrap(function predicateSpliterator$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          predicate = _ref.predicate;
          i = 0;
          _iterator = _createForOfIteratorHelper(source);
          _context.prev = 3;

          _iterator.s();

        case 5:
          if ((_step = _iterator.n()).done) {
            _context.next = 11;
            break;
          }

          value = _step.value;
          _context.next = 9;
          return predicate(value, i++) ? split : value;

        case 9:
          _context.next = 5;
          break;

        case 11:
          _context.next = 16;
          break;

        case 13:
          _context.prev = 13;
          _context.t0 = _context["catch"](3);

          _iterator.e(_context.t0);

        case 16:
          _context.prev = 16;

          _iterator.f();

          return _context.finish(16);

        case 19:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[3, 13, 16, 19]]);
}

function __splitWhen(source, predicate) {
  return __spliterate(source, predicateSpliterator, {
    predicate: predicate
  });
}

exports.__splitWhen = __splitWhen;
var splitWhen = /*#__PURE__*/iterableCurry(__splitWhen);
exports.splitWhen = splitWhen;
},{"../$spliterate/spliterate.js":374,"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],369:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(iterableOf);

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$map/async-map.js'),
    __asyncMap = _require2.__asyncMap;

function iterableOf(value) {
  return _regeneratorRuntime.wrap(function iterableOf$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          _context.next = 2;
          return value;

        case 2:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

function __asyncSplit(source) {
  return __asyncMap(source, function (value) {
    return iterableOf(value);
  });
}

exports.__asyncSplit = __asyncSplit;
var asyncSplit = /*#__PURE__*/asyncIterableCurry(__asyncSplit);
exports.asyncSplit = asyncSplit;
},{"../$map/async-map.js":337,"../../internal/async-iterable.js":480,"@babel/runtime/regenerator":65}],370:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(iterableOf);

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$map/map.js'),
    __map = _require2.__map;

function iterableOf(value) {
  return _regeneratorRuntime.wrap(function iterableOf$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          _context.next = 2;
          return value;

        case 2:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

function __split(source) {
  return __map(source, function (value) {
    return iterableOf(value);
  });
}

exports.__split = __split;
var split = /*#__PURE__*/iterableCurry(__split);
exports.split = split;
},{"../$map/map.js":338,"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],371:[function(require,module,exports){
var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../../internal/async-groups-iterator.js'),
    AsyncGroupsIterator = _require2.AsyncGroupsIterator;

var _require3 = require('../$map/async-map.js'),
    __asyncMap = _require3.__asyncMap;

var _require4 = require('../$wrap/async-wrap.js'),
    __asyncWrap = _require4.__asyncWrap;

function __asyncSpliterateGrouped(source, strategy) {
  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  return new AsyncGroupsIterator(source, strategy, options);
}

exports.__asyncSpliterateGrouped = __asyncSpliterateGrouped;
var asyncSpliterateGrouped = /*#__PURE__*/asyncIterableCurry(function $spliterateGrouped() {
  return __asyncMap(__asyncSpliterateGrouped.apply(void 0, arguments), __asyncWrap);
}, {
  minArgs: 1,
  maxArgs: 2,
  growRight: true
});
exports.asyncSpliterateGrouped = asyncSpliterateGrouped;
},{"../$map/async-map.js":337,"../$wrap/async-wrap.js":408,"../../internal/async-groups-iterator.js":478,"../../internal/async-iterable.js":480}],372:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../../internal/groups-iterator.js'),
    GroupsIterator = _require2.GroupsIterator;

var _require3 = require('../$map/map.js'),
    __map = _require3.__map;

var _require4 = require('../$wrap/wrap.js'),
    __wrap = _require4.__wrap;

function __spliterateGrouped(source, strategy) {
  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  return new GroupsIterator(source, strategy, options);
}

exports.__spliterateGrouped = __spliterateGrouped;
var spliterateGrouped = /*#__PURE__*/iterableCurry(function $spliterateGrouped() {
  return __map(__spliterateGrouped.apply(void 0, arguments), __wrap);
}, {
  minArgs: 1,
  maxArgs: 2,
  growRight: true
});
exports.spliterateGrouped = spliterateGrouped;
},{"../$map/map.js":338,"../$wrap/wrap.js":409,"../../internal/groups-iterator.js":491,"../../internal/iterable.js":493}],373:[function(require,module,exports){
var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../../internal/async-parts-iterator.js'),
    AsyncPartsIterator = _require2.AsyncPartsIterator;

var _require3 = require('../$map/async-map.js'),
    __asyncMap = _require3.__asyncMap;

var _require4 = require('../$wrap/async-wrap.js'),
    __asyncWrap = _require4.__asyncWrap;

function __asyncSpliterate(source, strategy) {
  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  return new AsyncPartsIterator(source, strategy, options);
}

exports.__asyncSpliterate = __asyncSpliterate;
var asyncSpliterate = /*#__PURE__*/asyncIterableCurry(function $spliterate() {
  return __asyncMap(__asyncSpliterate.apply(void 0, arguments), __asyncWrap);
}, {
  minArgs: 1,
  maxArgs: 2,
  growRight: true
});
exports.asyncSpliterate = asyncSpliterate;
},{"../$map/async-map.js":337,"../$wrap/async-wrap.js":408,"../../internal/async-iterable.js":480,"../../internal/async-parts-iterator.js":482}],374:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../../internal/parts-iterator.js'),
    PartsIterator = _require2.PartsIterator;

var _require3 = require('../$map/map.js'),
    __map = _require3.__map;

var _require4 = require('../$wrap/wrap.js'),
    __wrap = _require4.__wrap;

function __spliterate(source, strategy) {
  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  return new PartsIterator(source, strategy, options);
}

exports.__spliterate = __spliterate;
var spliterate = /*#__PURE__*/iterableCurry(function $spliterate() {
  return __map(__spliterate.apply(void 0, arguments), __wrap);
}, {
  minArgs: 1,
  maxArgs: 2,
  growRight: true
});
exports.spliterate = spliterate;
},{"../$map/map.js":338,"../$wrap/wrap.js":409,"../../internal/iterable.js":493,"../../internal/parts-iterator.js":496}],375:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry,
    asyncEnsureIterable = _require.asyncEnsureIterable;

var _require2 = require('../$zip-all/async-zip-all.js'),
    __asyncZipAll = _require2.__asyncZipAll;

var _require3 = require('../$peekerate/async-peekerate.js'),
    __asyncPeekerate = _require3.__asyncPeekerate;

var none = Symbol('none');

function _asyncStartsWithAnySeq(_x, _x2, _x3) {
  return _asyncStartsWithAnySeq2.apply(this, arguments);
}

function _asyncStartsWithAnySeq2() {
  _asyncStartsWithAnySeq2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(peekr, subseqPeekr, same) {
    var matches, value, seqValue, i;
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            if (!(subseqPeekr.done || subseqPeekr.value.includes(none))) {
              _context.next = 2;
              break;
            }

            return _context.abrupt("return", true);

          case 2:
            matches = subseqPeekr.value.map(function () {
              return true;
            });

          case 3:
            if (!(!peekr.done && !subseqPeekr.done)) {
              _context.next = 22;
              break;
            }

            value = peekr.value;
            seqValue = subseqPeekr.value;
            i = 0;

          case 7:
            if (!(i < seqValue.length)) {
              _context.next = 18;
              break;
            }

            if (matches[i]) {
              _context.next = 10;
              break;
            }

            return _context.abrupt("continue", 15);

          case 10:
            if (!(seqValue[i] === none)) {
              _context.next = 14;
              break;
            }

            return _context.abrupt("return", true);

          case 14:
            matches[i] = same(seqValue[i], value);

          case 15:
            i++;
            _context.next = 7;
            break;

          case 18:
            _context.next = 20;
            return Promise.all([subseqPeekr.advance(), peekr.advance()]);

          case 20:
            _context.next = 3;
            break;

          case 22:
            return _context.abrupt("return", subseqPeekr.done && matches.includes(true));

          case 23:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncStartsWithAnySeq2.apply(this, arguments);
}

exports._asyncStartsWithAnySeq = _asyncStartsWithAnySeq;

function __asyncStartsWithAnySeq(_x4, _x5) {
  return _asyncStartsWithAnySeq3.apply(this, arguments);
}

function _asyncStartsWithAnySeq3() {
  _asyncStartsWithAnySeq3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(iterable, seqs) {
    var same,
        peekr,
        subseqPeekr,
        seqFound,
        _args2 = arguments;
    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            same = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : Object.is;

            if (seqs.length) {
              _context2.next = 3;
              break;
            }

            return _context2.abrupt("return", false);

          case 3:
            _context2.next = 5;
            return __asyncPeekerate(iterable);

          case 5:
            peekr = _context2.sent;
            _context2.next = 8;
            return __asyncPeekerate(__asyncZipAll(seqs, {
              filler: none
            }));

          case 8:
            subseqPeekr = _context2.sent;
            _context2.next = 11;
            return _asyncStartsWithAnySeq(peekr, subseqPeekr, same);

          case 11:
            seqFound = _context2.sent;
            _context2.next = 14;
            return subseqPeekr["return"]();

          case 14:
            _context2.next = 16;
            return peekr["return"]();

          case 16:
            return _context2.abrupt("return", seqFound);

          case 17:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2);
  }));
  return _asyncStartsWithAnySeq3.apply(this, arguments);
}

exports.__asyncStartsWithAnySeq = __asyncStartsWithAnySeq;
var asyncStartsWithAnySeq = /*#__PURE__*/asyncIterableCurry(__asyncStartsWithAnySeq, {
  minArgs: 1,
  maxArgs: 2,
  reduces: true,
  validateArgs: function validateArgs(args) {
    args[1] = args[1].map(function (arg) {
      return asyncEnsureIterable(arg);
    });
  }
});
exports.asyncStartsWithAnySeq = asyncStartsWithAnySeq;
},{"../$peekerate/async-peekerate.js":339,"../$zip-all/async-zip-all.js":410,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],376:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry,
    ensureIterable = _require.ensureIterable;

var _require2 = require('../$zip-all/zip-all.js'),
    __zipAll = _require2.__zipAll;

var _require3 = require('../$peekerate/peekerate.js'),
    __peekerate = _require3.__peekerate;

var none = Symbol('none');

function _startsWithAnySeq(peekr, subseqPeekr, same) {
  if (subseqPeekr.done || subseqPeekr.value.includes(none)) return true;
  var matches = subseqPeekr.value.map(function () {
    return true;
  });

  while (!peekr.done && !subseqPeekr.done) {
    var value = peekr.value;
    var seqValue = subseqPeekr.value;

    for (var i = 0; i < seqValue.length; i++) {
      if (!matches[i]) continue;

      if (seqValue[i] === none) {
        return true;
      } else {
        matches[i] = same(seqValue[i], value);
      }
    }

    subseqPeekr.advance();
    peekr.advance();
  }

  return subseqPeekr.done && matches.includes(true);
}

exports._startsWithAnySeq = _startsWithAnySeq;

function __startsWithAnySeq(iterable, seqs) {
  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;
  if (!seqs.length) return false;

  var peekr = __peekerate(iterable);

  var subseqPeekr = __peekerate(__zipAll(seqs, {
    filler: none
  }));

  var seqFound = _startsWithAnySeq(peekr, subseqPeekr, same);

  subseqPeekr["return"]();
  peekr["return"]();
  return seqFound;
}

exports.__startsWithAnySeq = __startsWithAnySeq;
var startsWithAnySeq = /*#__PURE__*/iterableCurry(__startsWithAnySeq, {
  minArgs: 1,
  maxArgs: 2,
  reduces: true,
  validateArgs: function validateArgs(args) {
    args[1] = args[1].map(function (arg) {
      return ensureIterable(arg);
    });
  }
});
exports.startsWithAnySeq = startsWithAnySeq;
},{"../$peekerate/peekerate.js":340,"../$zip-all/zip-all.js":411,"../../internal/iterable.js":493}],377:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$first-or/async-first-or.js'),
    __asyncFirstOr = _require2.__asyncFirstOr;

var _require3 = require('../$includes/includes.js'),
    __includes = _require3.__includes;

var none = Symbol('none');

function __asyncStartsWithAny(_x, _x2) {
  return _asyncStartsWithAny.apply(this, arguments);
}

function _asyncStartsWithAny() {
  _asyncStartsWithAny = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, values) {
    var same,
        first,
        _args = arguments;
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            same = _args.length > 2 && _args[2] !== undefined ? _args[2] : Object.is;
            _context.next = 3;
            return __asyncFirstOr(iterable, none);

          case 3:
            first = _context.sent;

            if (!(first === none)) {
              _context.next = 6;
              break;
            }

            return _context.abrupt("return", false);

          case 6:
            return _context.abrupt("return", __includes(values, first, function (a, b) {
              return same(b, a);
            }));

          case 7:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncStartsWithAny.apply(this, arguments);
}

exports.__asyncStartsWithAny = __asyncStartsWithAny;
var asyncStartsWithAny = /*#__PURE__*/asyncIterableCurry(__asyncStartsWithAny, {
  minArgs: 1,
  maxArgs: 2,
  reduces: true,
  validateArgs: function validateArgs(args) {}
});
exports.asyncStartsWithAny = asyncStartsWithAny;
},{"../$first-or/async-first-or.js":298,"../$includes/includes.js":320,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],378:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$first-or/first-or.js'),
    __firstOr = _require2.__firstOr;

var _require3 = require('../$includes/includes.js'),
    __includes = _require3.__includes;

var none = Symbol('none');

function __startsWithAny(iterable, values) {
  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;

  var first = __firstOr(iterable, none);

  if (first === none) return false;
  return __includes(values, first, function (a, b) {
    return same(b, a);
  });
}

exports.__startsWithAny = __startsWithAny;
var startsWithAny = /*#__PURE__*/iterableCurry(__startsWithAny, {
  minArgs: 1,
  maxArgs: 2,
  reduces: true,
  validateArgs: function validateArgs(args) {
    if (true && typeof args[0] === 'string') {
      console.warn('For string inputs use startsWithAnySeq instead of startsWithAny');
    }
  }
});
exports.startsWithAny = startsWithAny;
},{"../$first-or/first-or.js":299,"../$includes/includes.js":320,"../../internal/iterable.js":493}],379:[function(require,module,exports){
var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry,
    asyncEnsureIterable = _require.asyncEnsureIterable;

var _require2 = require('../$starts-with-any-seq/async-starts-with-any-seq.js'),
    __asyncStartsWithAnySeq = _require2.__asyncStartsWithAnySeq;

function __asyncStartsWithSeq(iterable, seq) {
  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;
  return __asyncStartsWithAnySeq(iterable, [seq], same);
}

exports.__asyncStartsWithSeq = __asyncStartsWithSeq;
var asyncStartsWithSeq = /*#__PURE__*/asyncIterableCurry(__asyncStartsWithSeq, {
  minArgs: 1,
  maxArgs: 2,
  reduces: true,
  validateArgs: function validateArgs(args) {
    args[1] = asyncEnsureIterable(args[1]);
  }
});
exports.asyncStartsWithSeq = asyncStartsWithSeq;
},{"../$starts-with-any-seq/async-starts-with-any-seq.js":375,"../../internal/async-iterable.js":480}],380:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry,
    ensureIterable = _require.ensureIterable;

var _require2 = require('../$starts-with-any-seq/starts-with-any-seq.js'),
    __startsWithAnySeq = _require2.__startsWithAnySeq;

function __startsWithSeq(iterable, seq) {
  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;
  return __startsWithAnySeq(iterable, [seq], same);
}

exports.__startsWithSeq = __startsWithSeq;
var startsWithSeq = /*#__PURE__*/iterableCurry(__startsWithSeq, {
  minArgs: 1,
  maxArgs: 2,
  reduces: true,
  validateArgs: function validateArgs(args) {
    args[1] = ensureIterable(args[1]);
  }
});
exports.startsWithSeq = startsWithSeq;
},{"../$starts-with-any-seq/starts-with-any-seq.js":376,"../../internal/iterable.js":493}],381:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$first-or/async-first-or.js'),
    __asyncFirstOr = _require2.__asyncFirstOr;

var none = Symbol('none');

function __asyncStartsWith(_x, _x2) {
  return _asyncStartsWith.apply(this, arguments);
}

function _asyncStartsWith() {
  _asyncStartsWith = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, value) {
    var same,
        first,
        _args = arguments;
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            same = _args.length > 2 && _args[2] !== undefined ? _args[2] : Object.is;
            _context.next = 3;
            return __asyncFirstOr(iterable, none);

          case 3:
            first = _context.sent;

            if (!(first === none)) {
              _context.next = 6;
              break;
            }

            return _context.abrupt("return", false);

          case 6:
            return _context.abrupt("return", same(value, first));

          case 7:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncStartsWith.apply(this, arguments);
}

exports.__asyncStartsWith = __asyncStartsWith;
var asyncStartsWith = /*#__PURE__*/asyncIterableCurry(__asyncStartsWith, {
  minArgs: 1,
  maxArgs: 2,
  reduces: true,
  validateArgs: function validateArgs(args) {}
});
exports.asyncStartsWith = asyncStartsWith;
},{"../$first-or/async-first-or.js":298,"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],382:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$first-or/first-or.js'),
    __firstOr = _require2.__firstOr;

var none = Symbol('none');

function __startsWith(iterable, value) {
  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;

  var first = __firstOr(iterable, none);

  if (first === none) return false;
  return same(value, first);
}

exports.__startsWith = __startsWith;
var startsWith = /*#__PURE__*/iterableCurry(__startsWith, {
  minArgs: 1,
  maxArgs: 2,
  reduces: true,
  validateArgs: function validateArgs(args) {
    if (true && typeof args[0] === 'string') {
      console.warn('For string inputs use startsWithSeq instead of startsWith');
    }
  }
});
exports.startsWith = startsWith;
},{"../$first-or/first-or.js":299,"../../internal/iterable.js":493}],383:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

function __asyncStr(_x) {
  return _asyncStr.apply(this, arguments);
}

function _asyncStr() {
  _asyncStr = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(chars) {
    var result, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, _char;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            result = '';
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 3;
            _iterator = _asyncIterator(chars);

          case 5:
            _context.next = 7;
            return _iterator.next();

          case 7:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 11;
            return _step.value;

          case 11:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 18;
              break;
            }

            _char = _value;
            result += _char.toString();

          case 15:
            _iteratorNormalCompletion = true;
            _context.next = 5;
            break;

          case 18:
            _context.next = 24;
            break;

          case 20:
            _context.prev = 20;
            _context.t0 = _context["catch"](3);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 24:
            _context.prev = 24;
            _context.prev = 25;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 29;
              break;
            }

            _context.next = 29;
            return _iterator["return"]();

          case 29:
            _context.prev = 29;

            if (!_didIteratorError) {
              _context.next = 32;
              break;
            }

            throw _iteratorError;

          case 32:
            return _context.finish(29);

          case 33:
            return _context.finish(24);

          case 34:
            return _context.abrupt("return", result);

          case 35:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[3, 20, 24, 34], [25,, 29, 33]]);
  }));
  return _asyncStr.apply(this, arguments);
}

exports.__asyncStr = __asyncStr;
var asyncStr = /*#__PURE__*/asyncIterableCurry(__asyncStr, {
  reduces: true
});
exports.asyncStr = asyncStr;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],384:[function(require,module,exports){
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

function __str(chars) {
  var result = '';

  var _iterator = _createForOfIteratorHelper(chars),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var _char = _step.value;
      result += _char.toString();
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

  return result;
}

exports.__str = __str;
var str = /*#__PURE__*/iterableCurry(__str, {
  reduces: true
});
exports.str = str;
},{"../../internal/iterable.js":493}],385:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

function __asyncTakeLastOr(_x, _x2) {
  return _asyncTakeLastOr.apply(this, arguments);
}

function _asyncTakeLastOr() {
  _asyncTakeLastOr = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, whenEmpty) {
    var _value, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value2, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _value = whenEmpty;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 3;
            _iterator = _asyncIterator(iterable);

          case 5:
            _context.next = 7;
            return _iterator.next();

          case 7:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 11;
            return _step.value;

          case 11:
            _value2 = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 18;
              break;
            }

            value = _value2;
            _value = value;

          case 15:
            _iteratorNormalCompletion = true;
            _context.next = 5;
            break;

          case 18:
            _context.next = 24;
            break;

          case 20:
            _context.prev = 20;
            _context.t0 = _context["catch"](3);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 24:
            _context.prev = 24;
            _context.prev = 25;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 29;
              break;
            }

            _context.next = 29;
            return _iterator["return"]();

          case 29:
            _context.prev = 29;

            if (!_didIteratorError) {
              _context.next = 32;
              break;
            }

            throw _iteratorError;

          case 32:
            return _context.finish(29);

          case 33:
            return _context.finish(24);

          case 34:
            return _context.abrupt("return", _value);

          case 35:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[3, 20, 24, 34], [25,, 29, 33]]);
  }));
  return _asyncTakeLastOr.apply(this, arguments);
}

exports.__asyncTakeLastOr = __asyncTakeLastOr;
var asyncTakeLastOr = /*#__PURE__*/asyncIterableCurry(__asyncTakeLastOr, {
  reduces: true
});
exports.asyncTakeLastOr = asyncTakeLastOr;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],386:[function(require,module,exports){
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

function __takeLastOr(iterable, whenEmpty) {
  var _value = whenEmpty;

  var _iterator = _createForOfIteratorHelper(iterable),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var value = _step.value;
      _value = value;
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

  return _value;
}

exports.__takeLastOr = __takeLastOr;
var takeLastOr = /*#__PURE__*/iterableCurry(__takeLastOr, {
  reduces: true
});
exports.takeLastOr = takeLastOr;
},{"../../internal/iterable.js":493}],387:[function(require,module,exports){
var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../$take-last-or/async-take-last-or.js'),
    __asyncTakeLastOr = _require2.__asyncTakeLastOr;

function __asyncTakeLast(iterable) {
  return __asyncTakeLastOr(iterable, undefined);
}

exports.__asyncTakeLast = __asyncTakeLast;
var asyncTakeLast = /*#__PURE__*/asyncIterableCurry(__asyncTakeLast, {
  reduces: true
});
exports.asyncTakeLast = asyncTakeLast;
},{"../$take-last-or/async-take-last-or.js":385,"../../internal/async-iterable.js":480}],388:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../$take-last-or/take-last-or.js'),
    __takeLastOr = _require2.__takeLastOr;

function __takeLast(iterable) {
  return __takeLastOr(iterable, undefined);
}

exports.__takeLast = __takeLast;
var takeLast = /*#__PURE__*/iterableCurry(__takeLast, {
  reduces: true
});
exports.takeLast = takeLast;
},{"../$take-last-or/take-last-or.js":386,"../../internal/iterable.js":493}],389:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../../internal/compare.js'),
    defaultCompareOrder = _require2.defaultCompareOrder;

var _require3 = require('./internal/heap.js'),
    Heap = _require3.Heap;

function __asyncTakeSorted(_x) {
  return _asyncTakeSorted.apply(this, arguments);
}

exports.__asyncTakeSorted = __asyncTakeSorted;

function _asyncTakeSorted() {
  _asyncTakeSorted = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source) {
    var n,
        compare,
        heap,
        _iteratorNormalCompletion,
        _didIteratorError,
        _iteratorError,
        _iterator,
        _step,
        _value,
        value,
        _args = arguments;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            n = _args.length > 1 && _args[1] !== undefined ? _args[1] : Infinity;
            compare = _args.length > 2 && _args[2] !== undefined ? _args[2] : defaultCompareOrder;
            heap = new Heap(compare);
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 5;
            _iterator = _asyncIterator(source);

          case 7:
            _context.next = 9;
            return _awaitAsyncGenerator(_iterator.next());

          case 9:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 13;
            return _awaitAsyncGenerator(_step.value);

          case 13:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 21;
              break;
            }

            value = _value;
            heap.push(value);

            if (heap.size > n) {
              heap.pop();
            }

          case 18:
            _iteratorNormalCompletion = true;
            _context.next = 7;
            break;

          case 21:
            _context.next = 27;
            break;

          case 23:
            _context.prev = 23;
            _context.t0 = _context["catch"](5);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 27:
            _context.prev = 27;
            _context.prev = 28;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 32;
              break;
            }

            _context.next = 32;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 32:
            _context.prev = 32;

            if (!_didIteratorError) {
              _context.next = 35;
              break;
            }

            throw _iteratorError;

          case 35:
            return _context.finish(32);

          case 36:
            return _context.finish(27);

          case 37:
            if (!heap.size) {
              _context.next = 42;
              break;
            }

            _context.next = 40;
            return heap.pop();

          case 40:
            _context.next = 37;
            break;

          case 42:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[5, 23, 27, 37], [28,, 32, 36]]);
  }));
  return _asyncTakeSorted.apply(this, arguments);
}

var asyncTakeSorted = /*#__PURE__*/asyncIterableCurry(__asyncTakeSorted, {
  minArgs: 0,
  maxArgs: 2,
  validateArgs: function validateArgs(args) {
    if (typeof args[1] === 'function') {
      var temp = args[2];
      args[2] = args[1];
      args[1] = temp;
    }
  }
});
exports.asyncTakeSorted = asyncTakeSorted;
},{"../../internal/async-iterable.js":480,"../../internal/compare.js":487,"./internal/heap.js":390,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],390:[function(require,module,exports){
var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

var _createClass = require("@babel/runtime/helpers/createClass");

function swap(arr, x, y) {
  var tmp = arr[x];
  arr[x] = arr[y];
  arr[y] = tmp;
}

var Heap = /*#__PURE__*/function () {
  function Heap(compare) {
    _classCallCheck(this, Heap);

    this.compare = compare;
    this.data = [];
  }

  _createClass(Heap, [{
    key: "_bubbleUp",
    value: function _bubbleUp(i) {
      var data = this.data,
          compare = this.compare;
      var parentIndex;

      while (i > 0) {
        parentIndex = Heap.getParentIndex(i);

        if (compare(data[i], data[parentIndex]) < 0) {
          swap(this.data, i, parentIndex);
          i = parentIndex;
        } else {
          return i;
        }
      }
    }
  }, {
    key: "_heapify",
    value: function _heapify(i) {
      var data = this.data,
          compare = this.compare;
      var lIdx = Heap.getLeftIndex(i);
      var rIdx = Heap.getRightIndex(i);
      var leftIsSmaller = this.has(lIdx) ? compare(data[lIdx], data[i]) < 0 : false;
      var rightIsSmaller = this.has(rIdx) ? compare(data[rIdx], data[i]) < 0 : false;

      if (leftIsSmaller && rightIsSmaller) {
        if (compare(data[lIdx], data[rIdx]) < 0) {
          swap(this.data, lIdx, i);
          return lIdx;
        } else {
          swap(this.data, rIdx, i);
          return rIdx;
        }
      } else if (leftIsSmaller) {
        swap(this.data, lIdx, i);
        return lIdx;
      } else if (rightIsSmaller) {
        swap(this.data, rIdx, i);
        return rIdx;
      }
    }
  }, {
    key: "_bubbleDown",
    value: function _bubbleDown(i) {
      var size = this.size;

      while (i !== null && i < size) {
        i = this._heapify(i);
      }
    }
  }, {
    key: "push",
    value: function push(value) {
      this.data.push(value);

      this._bubbleUp(this.size - 1);
    }
  }, {
    key: "pop",
    value: function pop() {
      if (!this.size) return;
      var root = this.data[0];
      var last = this.data.pop();

      if (this.size > 0) {
        this.data[0] = last;

        this._bubbleDown(0);
      }

      return root;
    }
  }, {
    key: "has",
    value: function has(idx) {
      return idx > 0 && idx < this.size;
    }
  }, {
    key: "size",
    get: function get() {
      return this.data.length;
    }
  }], [{
    key: "getParentIndex",
    value: function getParentIndex(i) {
      return i % 2 ? (i - 1) / 2 : Math.floor((i - 1) / 2);
    }
  }, {
    key: "getLeftIndex",
    value: function getLeftIndex(i) {
      return 2 * i + 1;
    }
  }, {
    key: "getRightIndex",
    value: function getRightIndex(i) {
      return 2 * i + 2;
    }
  }]);

  return Heap;
}();

exports.Heap = Heap;
},{"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/createClass":47}],391:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__takeSorted);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../../internal/compare.js'),
    defaultCompareOrder = _require2.defaultCompareOrder;

var _require3 = require('./internal/heap.js'),
    Heap = _require3.Heap;

function __takeSorted(source) {
  var n,
      compare,
      heap,
      _iterator,
      _step,
      value,
      _args = arguments;

  return _regeneratorRuntime.wrap(function __takeSorted$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          n = _args.length > 1 && _args[1] !== undefined ? _args[1] : Infinity;
          compare = _args.length > 2 && _args[2] !== undefined ? _args[2] : defaultCompareOrder;
          heap = new Heap(compare);
          _iterator = _createForOfIteratorHelper(source);

          try {
            for (_iterator.s(); !(_step = _iterator.n()).done;) {
              value = _step.value;
              heap.push(value);

              if (heap.size > n) {
                heap.pop();
              }
            }
          } catch (err) {
            _iterator.e(err);
          } finally {
            _iterator.f();
          }

        case 5:
          if (!heap.size) {
            _context.next = 10;
            break;
          }

          _context.next = 8;
          return heap.pop();

        case 8:
          _context.next = 5;
          break;

        case 10:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

exports.__takeSorted = __takeSorted;
var takeSorted = /*#__PURE__*/iterableCurry(__takeSorted, {
  minArgs: 0,
  maxArgs: 2,
  validateArgs: function validateArgs(args) {
    if (typeof args[1] === 'function') {
      var temp = args[2];
      args[2] = args[1];
      args[1] = temp;
    }
  }
});
exports.takeSorted = takeSorted;
},{"../../internal/compare.js":487,"../../internal/iterable.js":493,"./internal/heap.js":390,"@babel/runtime/regenerator":65}],392:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

function __asyncTakeWhile(_x, _x2) {
  return _asyncTakeWhile.apply(this, arguments);
}

exports.__asyncTakeWhile = __asyncTakeWhile;

function _asyncTakeWhile() {
  _asyncTakeWhile = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, predicate) {
    var take, c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            take = true;
            c = 0;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 4;
            _iterator = _asyncIterator(source);

          case 6:
            _context.next = 8;
            return _awaitAsyncGenerator(_iterator.next());

          case 8:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 12;
            return _awaitAsyncGenerator(_step.value);

          case 12:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 27;
              break;
            }

            value = _value;
            _context.next = 17;
            return _awaitAsyncGenerator(predicate(value, c++));

          case 17:
            take = _context.sent;

            if (!take) {
              _context.next = 23;
              break;
            }

            _context.next = 21;
            return value;

          case 21:
            _context.next = 24;
            break;

          case 23:
            return _context.abrupt("break", 27);

          case 24:
            _iteratorNormalCompletion = true;
            _context.next = 6;
            break;

          case 27:
            _context.next = 33;
            break;

          case 29:
            _context.prev = 29;
            _context.t0 = _context["catch"](4);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 33:
            _context.prev = 33;
            _context.prev = 34;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 38;
              break;
            }

            _context.next = 38;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 38:
            _context.prev = 38;

            if (!_didIteratorError) {
              _context.next = 41;
              break;
            }

            throw _iteratorError;

          case 41:
            return _context.finish(38);

          case 42:
            return _context.finish(33);

          case 43:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[4, 29, 33, 43], [34,, 38, 42]]);
  }));
  return _asyncTakeWhile.apply(this, arguments);
}

var asyncTakeWhile = /*#__PURE__*/asyncIterableCurry(__asyncTakeWhile);
exports.asyncTakeWhile = asyncTakeWhile;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],393:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__takeWhile);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

function __takeWhile(source, predicate) {
  var take, c, _iterator, _step, value;

  return _regeneratorRuntime.wrap(function __takeWhile$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          take = true;
          c = 0;
          _iterator = _createForOfIteratorHelper(source);
          _context.prev = 3;

          _iterator.s();

        case 5:
          if ((_step = _iterator.n()).done) {
            _context.next = 16;
            break;
          }

          value = _step.value;
          take = predicate(value, c++);

          if (!take) {
            _context.next = 13;
            break;
          }

          _context.next = 11;
          return value;

        case 11:
          _context.next = 14;
          break;

        case 13:
          return _context.abrupt("break", 16);

        case 14:
          _context.next = 5;
          break;

        case 16:
          _context.next = 21;
          break;

        case 18:
          _context.prev = 18;
          _context.t0 = _context["catch"](3);

          _iterator.e(_context.t0);

        case 21:
          _context.prev = 21;

          _iterator.f();

          return _context.finish(21);

        case 24:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[3, 18, 21, 24]]);
}

exports.__takeWhile = __takeWhile;
var takeWhile = /*#__PURE__*/iterableCurry(__takeWhile);
exports.takeWhile = takeWhile;
},{"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],394:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

function __asyncTake(_x, _x2) {
  return _asyncTake.apply(this, arguments);
}

exports.__asyncTake = __asyncTake;

function _asyncTake() {
  _asyncTake = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, n) {
    var i, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            if (!(n === 0)) {
              _context.next = 2;
              break;
            }

            return _context.abrupt("return");

          case 2:
            i = 0;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 5;
            _iterator = _asyncIterator(iterable);

          case 7:
            _context.next = 9;
            return _awaitAsyncGenerator(_iterator.next());

          case 9:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 13;
            return _awaitAsyncGenerator(_step.value);

          case 13:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 23;
              break;
            }

            value = _value;
            _context.next = 18;
            return value;

          case 18:
            if (!(++i === n)) {
              _context.next = 20;
              break;
            }

            return _context.abrupt("break", 23);

          case 20:
            _iteratorNormalCompletion = true;
            _context.next = 7;
            break;

          case 23:
            _context.next = 29;
            break;

          case 25:
            _context.prev = 25;
            _context.t0 = _context["catch"](5);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 29:
            _context.prev = 29;
            _context.prev = 30;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 34;
              break;
            }

            _context.next = 34;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 34:
            _context.prev = 34;

            if (!_didIteratorError) {
              _context.next = 37;
              break;
            }

            throw _iteratorError;

          case 37:
            return _context.finish(34);

          case 38:
            return _context.finish(29);

          case 39:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[5, 25, 29, 39], [30,, 34, 38]]);
  }));
  return _asyncTake.apply(this, arguments);
}

var asyncTake = /*#__PURE__*/asyncIterableCurry(__asyncTake);
exports.asyncTake = asyncTake;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],395:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__take);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

function __take(iterable, n) {
  var i, _iterator, _step, value;

  return _regeneratorRuntime.wrap(function __take$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          if (!(n === 0)) {
            _context.next = 2;
            break;
          }

          return _context.abrupt("return");

        case 2:
          i = 0;
          _iterator = _createForOfIteratorHelper(iterable);
          _context.prev = 4;

          _iterator.s();

        case 6:
          if ((_step = _iterator.n()).done) {
            _context.next = 14;
            break;
          }

          value = _step.value;
          _context.next = 10;
          return value;

        case 10:
          if (!(++i === n)) {
            _context.next = 12;
            break;
          }

          return _context.abrupt("break", 14);

        case 12:
          _context.next = 6;
          break;

        case 14:
          _context.next = 19;
          break;

        case 16:
          _context.prev = 16;
          _context.t0 = _context["catch"](4);

          _iterator.e(_context.t0);

        case 19:
          _context.prev = 19;

          _iterator.f();

          return _context.finish(19);

        case 22:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[4, 16, 19, 22]]);
}

exports.__take = __take;
var take = /*#__PURE__*/iterableCurry(__take);
exports.take = take;
},{"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],396:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

function __asyncTap(_x, _x2) {
  return _asyncTap.apply(this, arguments);
}

exports.__asyncTap = __asyncTap;

function _asyncTap() {
  _asyncTap = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, callback) {
    var c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            c = 0;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 3;
            _iterator = _asyncIterator(source);

          case 5:
            _context.next = 7;
            return _awaitAsyncGenerator(_iterator.next());

          case 7:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 11;
            return _awaitAsyncGenerator(_step.value);

          case 11:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 20;
              break;
            }

            value = _value;
            callback(value, c++);
            _context.next = 17;
            return value;

          case 17:
            _iteratorNormalCompletion = true;
            _context.next = 5;
            break;

          case 20:
            _context.next = 26;
            break;

          case 22:
            _context.prev = 22;
            _context.t0 = _context["catch"](3);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 26:
            _context.prev = 26;
            _context.prev = 27;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 31;
              break;
            }

            _context.next = 31;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 31:
            _context.prev = 31;

            if (!_didIteratorError) {
              _context.next = 34;
              break;
            }

            throw _iteratorError;

          case 34:
            return _context.finish(31);

          case 35:
            return _context.finish(26);

          case 36:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[3, 22, 26, 36], [27,, 31, 35]]);
  }));
  return _asyncTap.apply(this, arguments);
}

var asyncTap = /*#__PURE__*/asyncIterableCurry(__asyncTap);
exports.asyncTap = asyncTap;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],397:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__tap);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

function __tap(source, callback) {
  var c, _iterator, _step, value;

  return _regeneratorRuntime.wrap(function __tap$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          c = 0;
          _iterator = _createForOfIteratorHelper(source);
          _context.prev = 2;

          _iterator.s();

        case 4:
          if ((_step = _iterator.n()).done) {
            _context.next = 11;
            break;
          }

          value = _step.value;
          callback(value, c++);
          _context.next = 9;
          return value;

        case 9:
          _context.next = 4;
          break;

        case 11:
          _context.next = 16;
          break;

        case 13:
          _context.prev = 13;
          _context.t0 = _context["catch"](2);

          _iterator.e(_context.t0);

        case 16:
          _context.prev = 16;

          _iterator.f();

          return _context.finish(16);

        case 19:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[2, 13, 16, 19]]);
}

exports.__tap = __tap;
var tap = /*#__PURE__*/iterableCurry(__tap);
exports.tap = tap;
},{"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],398:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncEnsureIterable = _require.asyncEnsureIterable;

function __asyncToArray(_x) {
  return _asyncToArray.apply(this, arguments);
}

function _asyncToArray() {
  _asyncToArray = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source) {
    var out, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            out = [];
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 3;
            _iterator = _asyncIterator(source);

          case 5:
            _context.next = 7;
            return _iterator.next();

          case 7:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 11;
            return _step.value;

          case 11:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 18;
              break;
            }

            value = _value;
            out.push(value);

          case 15:
            _iteratorNormalCompletion = true;
            _context.next = 5;
            break;

          case 18:
            _context.next = 24;
            break;

          case 20:
            _context.prev = 20;
            _context.t0 = _context["catch"](3);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 24:
            _context.prev = 24;
            _context.prev = 25;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 29;
              break;
            }

            _context.next = 29;
            return _iterator["return"]();

          case 29:
            _context.prev = 29;

            if (!_didIteratorError) {
              _context.next = 32;
              break;
            }

            throw _iteratorError;

          case 32:
            return _context.finish(29);

          case 33:
            return _context.finish(24);

          case 34:
            return _context.abrupt("return", out);

          case 35:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[3, 20, 24, 34], [25,, 29, 33]]);
  }));
  return _asyncToArray.apply(this, arguments);
}

exports.__asyncToArray = __asyncToArray;

function asyncToArray(source) {
  return __asyncToArray(asyncEnsureIterable(source));
}

exports.asyncToArray = asyncToArray;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],399:[function(require,module,exports){
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    ensureIterable = _require.ensureIterable;

function __toArray(source) {
  var out = [];

  var _iterator = _createForOfIteratorHelper(source),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var value = _step.value;
      out.push(value);
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

  return out;
}

exports.__toArray = __toArray;

function toArray(source) {
  return __toArray(ensureIterable(source));
}

exports.toArray = toArray;
},{"../../internal/iterable.js":493}],400:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _slicedToArray = require("@babel/runtime/helpers/slicedToArray");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncEnsureIterable = _require.asyncEnsureIterable;

function __asyncToObject(_x) {
  return _asyncToObject.apply(this, arguments);
}

function _asyncToObject() {
  _asyncToObject = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable) {
    var proto,
        obj,
        _iteratorNormalCompletion,
        _didIteratorError,
        _iteratorError,
        _iterator,
        _step,
        _value,
        _value2,
        _value3,
        key,
        value,
        _args = arguments;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            proto = _args.length > 1 && _args[1] !== undefined ? _args[1] : Object.prototype;
            obj = Object.create(proto);
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 4;
            _iterator = _asyncIterator(iterable);

          case 6:
            _context.next = 8;
            return _iterator.next();

          case 8:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 12;
            return _step.value;

          case 12:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 19;
              break;
            }

            _value2 = _value, _value3 = _slicedToArray(_value2, 2), key = _value3[0], value = _value3[1];
            obj[key] = value;

          case 16:
            _iteratorNormalCompletion = true;
            _context.next = 6;
            break;

          case 19:
            _context.next = 25;
            break;

          case 21:
            _context.prev = 21;
            _context.t0 = _context["catch"](4);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 25:
            _context.prev = 25;
            _context.prev = 26;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 30;
              break;
            }

            _context.next = 30;
            return _iterator["return"]();

          case 30:
            _context.prev = 30;

            if (!_didIteratorError) {
              _context.next = 33;
              break;
            }

            throw _iteratorError;

          case 33:
            return _context.finish(30);

          case 34:
            return _context.finish(25);

          case 35:
            return _context.abrupt("return", obj);

          case 36:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[4, 21, 25, 35], [26,, 30, 34]]);
  }));
  return _asyncToObject.apply(this, arguments);
}

exports.__asyncToObject = __asyncToObject;

function asyncToObject(iterable, proto) {
  return __asyncToObject(asyncEnsureIterable(iterable), proto);
}

exports.asyncToObject = asyncToObject;
},{"../../internal/async-iterable.js":480,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/helpers/slicedToArray":59,"@babel/runtime/regenerator":65}],401:[function(require,module,exports){
var _slicedToArray = require("@babel/runtime/helpers/slicedToArray");

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    ensureIterable = _require.ensureIterable;

function __toObject(iterable) {
  var proto = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Object.prototype;
  var obj = Object.create(proto);

  var _iterator = _createForOfIteratorHelper(iterable),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var _step$value = _slicedToArray(_step.value, 2),
          key = _step$value[0],
          value = _step$value[1];

      obj[key] = value;
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

  return obj;
}

exports.__toObject = __toObject;

function toObject(iterable, proto) {
  return __toObject(ensureIterable(iterable), proto);
}

exports.toObject = toObject;
},{"../../internal/iterable.js":493,"@babel/runtime/helpers/slicedToArray":59}],402:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../../internal/circular-buffer.js'),
    CircularBuffer = _require2.CircularBuffer,
    ReadOnlyCircularBuffer = _require2.ReadOnlyCircularBuffer;

function __asyncWindowAhead(_x, _x2) {
  return _asyncWindowAhead.apply(this, arguments);
}

exports.__asyncWindowAhead = __asyncWindowAhead;

function _asyncWindowAhead() {
  _asyncWindowAhead = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, size) {
    var _ref,
        _ref$filler,
        filler,
        _ref$useFiller,
        useFiller,
        buffer,
        bufferReadProxy,
        len,
        _iteratorNormalCompletion,
        _didIteratorError,
        _iteratorError,
        _iterator,
        _step,
        _value,
        value,
        i,
        _i,
        _args = arguments;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _ref = _args.length > 2 && _args[2] !== undefined ? _args[2] : {}, _ref$filler = _ref.filler, filler = _ref$filler === void 0 ? undefined : _ref$filler, _ref$useFiller = _ref.useFiller, useFiller = _ref$useFiller === void 0 ? true : _ref$useFiller;
            buffer = new CircularBuffer(size);
            bufferReadProxy = new ReadOnlyCircularBuffer(buffer);
            len = 0;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 6;
            _iterator = _asyncIterator(source);

          case 8:
            _context.next = 10;
            return _awaitAsyncGenerator(_iterator.next());

          case 10:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 14;
            return _awaitAsyncGenerator(_step.value);

          case 14:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 25;
              break;
            }

            value = _value;
            buffer.push(value);

            if (!buffer.isFull()) {
              _context.next = 21;
              break;
            }

            _context.next = 21;
            return bufferReadProxy;

          case 21:
            len++;

          case 22:
            _iteratorNormalCompletion = true;
            _context.next = 8;
            break;

          case 25:
            _context.next = 31;
            break;

          case 27:
            _context.prev = 27;
            _context.t0 = _context["catch"](6);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 31:
            _context.prev = 31;
            _context.prev = 32;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 36;
              break;
            }

            _context.next = 36;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 36:
            _context.prev = 36;

            if (!_didIteratorError) {
              _context.next = 39;
              break;
            }

            throw _iteratorError;

          case 39:
            return _context.finish(36);

          case 40:
            return _context.finish(31);

          case 41:
            if (useFiller) {
              for (i = len; i < size; i++) {
                buffer.push(filler);
              }
            }

            if (!(len > 0 && len < size)) {
              _context.next = 45;
              break;
            }

            _context.next = 45;
            return bufferReadProxy;

          case 45:
            _i = 0;

          case 46:
            if (!(_i < Math.min(size, len) - 1)) {
              _context.next = 54;
              break;
            }

            buffer.shift();

            if (useFiller) {
              buffer.push(filler);
            }

            _context.next = 51;
            return bufferReadProxy;

          case 51:
            _i++;
            _context.next = 46;
            break;

          case 54:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[6, 27, 31, 41], [32,, 36, 40]]);
  }));
  return _asyncWindowAhead.apply(this, arguments);
}

var asyncWindowAhead = /*#__PURE__*/asyncIterableCurry(__asyncWindowAhead, {
  minArgs: 1,
  maxArgs: 2,
  validateArgs: function validateArgs(args) {
    if (typeof args[1] !== 'number') {
      throw new Error('asyncWindowAhead'.concat(" must be passed a numeric size"));
    }
  }
});
exports.asyncWindowAhead = asyncWindowAhead;
},{"../../internal/async-iterable.js":480,"../../internal/circular-buffer.js":486,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],403:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__windowAhead);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../../internal/circular-buffer.js'),
    CircularBuffer = _require2.CircularBuffer,
    ReadOnlyCircularBuffer = _require2.ReadOnlyCircularBuffer;

function __windowAhead(source, size) {
  var _ref,
      _ref$filler,
      filler,
      _ref$useFiller,
      useFiller,
      buffer,
      bufferReadProxy,
      len,
      _iterator,
      _step,
      value,
      i,
      _i,
      _args = arguments;

  return _regeneratorRuntime.wrap(function __windowAhead$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          _ref = _args.length > 2 && _args[2] !== undefined ? _args[2] : {}, _ref$filler = _ref.filler, filler = _ref$filler === void 0 ? undefined : _ref$filler, _ref$useFiller = _ref.useFiller, useFiller = _ref$useFiller === void 0 ? true : _ref$useFiller;
          buffer = new CircularBuffer(size);
          bufferReadProxy = new ReadOnlyCircularBuffer(buffer);
          len = 0;
          _iterator = _createForOfIteratorHelper(source);
          _context.prev = 5;

          _iterator.s();

        case 7:
          if ((_step = _iterator.n()).done) {
            _context.next = 16;
            break;
          }

          value = _step.value;
          buffer.push(value);

          if (!buffer.isFull()) {
            _context.next = 13;
            break;
          }

          _context.next = 13;
          return bufferReadProxy;

        case 13:
          len++;

        case 14:
          _context.next = 7;
          break;

        case 16:
          _context.next = 21;
          break;

        case 18:
          _context.prev = 18;
          _context.t0 = _context["catch"](5);

          _iterator.e(_context.t0);

        case 21:
          _context.prev = 21;

          _iterator.f();

          return _context.finish(21);

        case 24:
          if (useFiller) {
            for (i = len; i < size; i++) {
              buffer.push(filler);
            }
          }

          if (!(len > 0 && len < size)) {
            _context.next = 28;
            break;
          }

          _context.next = 28;
          return bufferReadProxy;

        case 28:
          _i = 0;

        case 29:
          if (!(_i < Math.min(size, len) - 1)) {
            _context.next = 37;
            break;
          }

          buffer.shift();

          if (useFiller) {
            buffer.push(filler);
          }

          _context.next = 34;
          return bufferReadProxy;

        case 34:
          _i++;
          _context.next = 29;
          break;

        case 37:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[5, 18, 21, 24]]);
}

exports.__windowAhead = __windowAhead;
var windowAhead = /*#__PURE__*/iterableCurry(__windowAhead, {
  minArgs: 1,
  maxArgs: 2,
  validateArgs: function validateArgs(args) {
    if (typeof args[1] !== 'number') {
      throw new Error('windowAhead'.concat(" must be passed a numeric size"));
    }
  }
});
exports.windowAhead = windowAhead;
},{"../../internal/circular-buffer.js":486,"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],404:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../../internal/circular-buffer.js'),
    CircularBuffer = _require2.CircularBuffer,
    ReadOnlyCircularBuffer = _require2.ReadOnlyCircularBuffer;

function __asyncWindowBehind(_x, _x2) {
  return _asyncWindowBehind.apply(this, arguments);
}

exports.__asyncWindowBehind = __asyncWindowBehind;

function _asyncWindowBehind() {
  _asyncWindowBehind = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, size) {
    var _ref,
        filler,
        buffer,
        bufferReadProxy,
        _iteratorNormalCompletion,
        _didIteratorError,
        _iteratorError,
        _iterator,
        _step,
        _value,
        value,
        _args = arguments;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _ref = _args.length > 2 && _args[2] !== undefined ? _args[2] : {}, filler = _ref.filler;
            buffer = new CircularBuffer(size);
            bufferReadProxy = new ReadOnlyCircularBuffer(buffer);
            buffer.fill(filler);
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 6;
            _iterator = _asyncIterator(source);

          case 8:
            _context.next = 10;
            return _awaitAsyncGenerator(_iterator.next());

          case 10:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 14;
            return _awaitAsyncGenerator(_step.value);

          case 14:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 23;
              break;
            }

            value = _value;
            buffer.push(value);
            _context.next = 20;
            return bufferReadProxy;

          case 20:
            _iteratorNormalCompletion = true;
            _context.next = 8;
            break;

          case 23:
            _context.next = 29;
            break;

          case 25:
            _context.prev = 25;
            _context.t0 = _context["catch"](6);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 29:
            _context.prev = 29;
            _context.prev = 30;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 34;
              break;
            }

            _context.next = 34;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 34:
            _context.prev = 34;

            if (!_didIteratorError) {
              _context.next = 37;
              break;
            }

            throw _iteratorError;

          case 37:
            return _context.finish(34);

          case 38:
            return _context.finish(29);

          case 39:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[6, 25, 29, 39], [30,, 34, 38]]);
  }));
  return _asyncWindowBehind.apply(this, arguments);
}

var asyncWindowBehind = /*#__PURE__*/asyncIterableCurry(__asyncWindowBehind, {
  minArgs: 1,
  maxArgs: 2,
  validateArgs: function validateArgs(args) {
    if (typeof args[1] !== 'number') {
      throw new Error('asyncWindowBehind'.concat(" must be passed a numeric size"));
    }
  }
});
exports.asyncWindowBehind = asyncWindowBehind;
},{"../../internal/async-iterable.js":480,"../../internal/circular-buffer.js":486,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],405:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__windowBehind);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../../internal/circular-buffer.js'),
    CircularBuffer = _require2.CircularBuffer,
    ReadOnlyCircularBuffer = _require2.ReadOnlyCircularBuffer;

function __windowBehind(source, size) {
  var _ref,
      filler,
      buffer,
      bufferReadProxy,
      _iterator,
      _step,
      value,
      _args = arguments;

  return _regeneratorRuntime.wrap(function __windowBehind$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          _ref = _args.length > 2 && _args[2] !== undefined ? _args[2] : {}, filler = _ref.filler;
          buffer = new CircularBuffer(size);
          bufferReadProxy = new ReadOnlyCircularBuffer(buffer);
          buffer.fill(filler);
          _iterator = _createForOfIteratorHelper(source);
          _context.prev = 5;

          _iterator.s();

        case 7:
          if ((_step = _iterator.n()).done) {
            _context.next = 14;
            break;
          }

          value = _step.value;
          buffer.push(value);
          _context.next = 12;
          return bufferReadProxy;

        case 12:
          _context.next = 7;
          break;

        case 14:
          _context.next = 19;
          break;

        case 16:
          _context.prev = 16;
          _context.t0 = _context["catch"](5);

          _iterator.e(_context.t0);

        case 19:
          _context.prev = 19;

          _iterator.f();

          return _context.finish(19);

        case 22:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[5, 16, 19, 22]]);
}

exports.__windowBehind = __windowBehind;
var windowBehind = /*#__PURE__*/iterableCurry(__windowBehind, {
  minArgs: 1,
  maxArgs: 2,
  validateArgs: function validateArgs(args) {
    if (typeof args[1] !== 'number') {
      throw new Error('windowBehind'.concat(" must be passed a numeric size"));
    }
  }
});
exports.windowBehind = windowBehind;
},{"../../internal/circular-buffer.js":486,"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],406:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../../internal/circular-buffer.js'),
    CircularBuffer = _require2.CircularBuffer,
    ReadOnlyCircularBuffer = _require2.ReadOnlyCircularBuffer;

function __asyncWindow(_x, _x2) {
  return _asyncWindow.apply(this, arguments);
}

exports.__asyncWindow = __asyncWindow;

function _asyncWindow() {
  _asyncWindow = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, size) {
    var buffer, bufferReadProxy, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            buffer = new CircularBuffer(size);
            bufferReadProxy = new ReadOnlyCircularBuffer(buffer);
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 4;
            _iterator = _asyncIterator(source);

          case 6:
            _context.next = 8;
            return _awaitAsyncGenerator(_iterator.next());

          case 8:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 12;
            return _awaitAsyncGenerator(_step.value);

          case 12:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 22;
              break;
            }

            value = _value;
            buffer.push(value);

            if (!buffer.isFull()) {
              _context.next = 19;
              break;
            }

            _context.next = 19;
            return bufferReadProxy;

          case 19:
            _iteratorNormalCompletion = true;
            _context.next = 6;
            break;

          case 22:
            _context.next = 28;
            break;

          case 24:
            _context.prev = 24;
            _context.t0 = _context["catch"](4);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 28:
            _context.prev = 28;
            _context.prev = 29;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 33;
              break;
            }

            _context.next = 33;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 33:
            _context.prev = 33;

            if (!_didIteratorError) {
              _context.next = 36;
              break;
            }

            throw _iteratorError;

          case 36:
            return _context.finish(33);

          case 37:
            return _context.finish(28);

          case 38:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[4, 24, 28, 38], [29,, 33, 37]]);
  }));
  return _asyncWindow.apply(this, arguments);
}

var asyncWindow = /*#__PURE__*/asyncIterableCurry(__asyncWindow, {
  validateArgs: function validateArgs(args) {
    if (typeof args[1] !== 'number') {
      throw new Error('asyncWindow'.concat(" must be passed a numeric size"));
    }
  }
});
exports.asyncWindow = asyncWindow;
},{"../../internal/async-iterable.js":480,"../../internal/circular-buffer.js":486,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],407:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__window);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../../internal/circular-buffer.js'),
    CircularBuffer = _require2.CircularBuffer,
    ReadOnlyCircularBuffer = _require2.ReadOnlyCircularBuffer;

function __window(source, size) {
  var buffer, bufferReadProxy, _iterator, _step, value;

  return _regeneratorRuntime.wrap(function __window$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          buffer = new CircularBuffer(size);
          bufferReadProxy = new ReadOnlyCircularBuffer(buffer);
          _iterator = _createForOfIteratorHelper(source);
          _context.prev = 3;

          _iterator.s();

        case 5:
          if ((_step = _iterator.n()).done) {
            _context.next = 13;
            break;
          }

          value = _step.value;
          buffer.push(value);

          if (!buffer.isFull()) {
            _context.next = 11;
            break;
          }

          _context.next = 11;
          return bufferReadProxy;

        case 11:
          _context.next = 5;
          break;

        case 13:
          _context.next = 18;
          break;

        case 15:
          _context.prev = 15;
          _context.t0 = _context["catch"](3);

          _iterator.e(_context.t0);

        case 18:
          _context.prev = 18;

          _iterator.f();

          return _context.finish(18);

        case 21:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[3, 15, 18, 21]]);
}

exports.__window = __window;
var window = /*#__PURE__*/iterableCurry(__window, {
  validateArgs: function validateArgs(args) {
    if (typeof args[1] !== 'number') {
      throw new Error('window'.concat(" must be passed a numeric size"));
    }
  }
});
exports.window = window;
},{"../../internal/circular-buffer.js":486,"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],408:[function(require,module,exports){
var _require = require('../../internal/async-iterable.js'),
    asyncWrapWithIterableIterator = _require.asyncWrapWithIterableIterator;

var _require2 = require('../../internal/async-wrap.js'),
    __asyncWrap = _require2.asyncNullableWrap;

exports.__asyncWrap = __asyncWrap;
var asyncWrap = /*#__PURE__*/asyncWrapWithIterableIterator(__asyncWrap);
exports.asyncWrap = asyncWrap;
},{"../../internal/async-iterable.js":480,"../../internal/async-wrap.js":484}],409:[function(require,module,exports){
var _require = require('../../internal/iterable.js'),
    wrapWithIterableIterator = _require.wrapWithIterableIterator;

var _require2 = require('../../internal/wrap.js'),
    __wrap = _require2.nullableWrap;

exports.__wrap = __wrap;
var wrap = /*#__PURE__*/wrapWithIterableIterator(__wrap);
exports.wrap = wrap;
},{"../../internal/iterable.js":493,"../../internal/wrap.js":499}],410:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../../internal/async-parallel-each.js'),
    asyncParallelEach = _require2.asyncParallelEach;

var _require3 = require('../$peekerate/async-peekerate.js'),
    __asyncPeekerate = _require3.__asyncPeekerate;

var _require4 = require('../$map/async-map.js'),
    __asyncMap = _require4.__asyncMap;

var _require5 = require('../$every/every.js'),
    __every = _require5.__every;

var _require6 = require('../$to-array/async-to-array.js'),
    __asyncToArray = _require6.__asyncToArray;

var isDone = function isDone(peekr) {
  return peekr.done;
};

function __asyncZipAll(_x) {
  return _asyncZipAll.apply(this, arguments);
}

exports.__asyncZipAll = __asyncZipAll;

function _asyncZipAll() {
  _asyncZipAll = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(sources) {
    var _ref,
        filler,
        peekrs,
        done,
        _args = arguments;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _ref = _args.length > 1 && _args[1] !== undefined ? _args[1] : {}, filler = _ref.filler;
            _context.next = 3;
            return _awaitAsyncGenerator(__asyncToArray(__asyncMap(sources, __asyncPeekerate)));

          case 3:
            peekrs = _context.sent;
            done = __every(peekrs, isDone);
            _context.prev = 5;

          case 6:
            if (done) {
              _context.next = 14;
              break;
            }

            _context.next = 9;
            return peekrs.map(function (_ref2) {
              var value = _ref2.value,
                  done = _ref2.done;
              return done ? filler : value;
            });

          case 9:
            _context.next = 11;
            return _awaitAsyncGenerator(asyncParallelEach(peekrs, function (peekr) {
              return peekr.advance();
            }));

          case 11:
            done = __every(peekrs, isDone);
            _context.next = 6;
            break;

          case 14:
            _context.prev = 14;
            _context.next = 17;
            return _awaitAsyncGenerator(asyncParallelEach(peekrs, function (peekr) {
              return peekr["return"]();
            }));

          case 17:
            return _context.finish(14);

          case 18:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[5,, 14, 18]]);
  }));
  return _asyncZipAll.apply(this, arguments);
}

var asyncZipAll = /*#__PURE__*/asyncIterableCurry(__asyncZipAll, {
  variadic: true,
  minArgs: 0,
  maxArgs: 1
});
exports.asyncZipAll = asyncZipAll;
},{"../$every/every.js":287,"../$map/async-map.js":337,"../$peekerate/async-peekerate.js":339,"../$to-array/async-to-array.js":398,"../../internal/async-iterable.js":480,"../../internal/async-parallel-each.js":481,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],411:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__zipAll);

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../../internal/parallel-each.js'),
    parallelEach = _require2.parallelEach;

var _require3 = require('../$peekerate/peekerate.js'),
    __peekerate = _require3.__peekerate;

var _require4 = require('../$map/map.js'),
    __map = _require4.__map;

var _require5 = require('../$every/every.js'),
    __every = _require5.__every;

var _require6 = require('../$to-array/to-array.js'),
    __toArray = _require6.__toArray;

var isDone = function isDone(peekr) {
  return peekr.done;
};

function __zipAll(sources) {
  var _ref,
      filler,
      peekrs,
      done,
      _args = arguments;

  return _regeneratorRuntime.wrap(function __zipAll$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          _ref = _args.length > 1 && _args[1] !== undefined ? _args[1] : {}, filler = _ref.filler;
          peekrs = __toArray(__map(sources, __peekerate));
          done = __every(peekrs, isDone);
          _context.prev = 3;

        case 4:
          if (done) {
            _context.next = 11;
            break;
          }

          _context.next = 7;
          return peekrs.map(function (_ref2) {
            var value = _ref2.value,
                done = _ref2.done;
            return done ? filler : value;
          });

        case 7:
          parallelEach(peekrs, function (peekr) {
            return peekr.advance();
          });
          done = __every(peekrs, isDone);
          _context.next = 4;
          break;

        case 11:
          _context.prev = 11;
          parallelEach(peekrs, function (peekr) {
            return peekr["return"]();
          });
          return _context.finish(11);

        case 14:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[3,, 11, 14]]);
}

exports.__zipAll = __zipAll;
var zipAll = /*#__PURE__*/iterableCurry(__zipAll, {
  variadic: true,
  minArgs: 0,
  maxArgs: 1
});
exports.zipAll = zipAll;
},{"../$every/every.js":287,"../$map/map.js":338,"../$peekerate/peekerate.js":340,"../$to-array/to-array.js":399,"../../internal/iterable.js":493,"../../internal/parallel-each.js":495,"@babel/runtime/regenerator":65}],412:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../../internal/async-parallel-each.js'),
    asyncParallelEach = _require2.asyncParallelEach;

var _require3 = require('../$peekerate/async-peekerate.js'),
    __asyncPeekerate = _require3.__asyncPeekerate;

var _require4 = require('../$map/async-map.js'),
    __asyncMap = _require4.__asyncMap;

var _require5 = require('../$map/map.js'),
    __map = _require5.__map;

var _require6 = require('../$some/some.js'),
    __some = _require6.__some;

var _require7 = require('../$to-array/async-to-array.js'),
    __asyncToArray = _require7.__asyncToArray;

var isDone = function isDone(peekr) {
  return peekr.done;
};

function __asyncZip(_x) {
  return _asyncZip.apply(this, arguments);
}

exports.__asyncZip = __asyncZip;

function _asyncZip() {
  _asyncZip = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(sources) {
    var peekrs, done;
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.next = 2;
            return _awaitAsyncGenerator(__asyncToArray(__asyncMap(sources, __asyncPeekerate)));

          case 2:
            peekrs = _context.sent;
            done = __some(peekrs, isDone);
            _context.prev = 4;

          case 5:
            if (done) {
              _context.next = 13;
              break;
            }

            _context.next = 8;
            return peekrs.map(function (_ref) {
              var value = _ref.value;
              return value;
            });

          case 8:
            _context.next = 10;
            return _awaitAsyncGenerator(Promise.all(__map(peekrs, function (peekr) {
              return peekr.advance();
            })));

          case 10:
            done = __some(peekrs, isDone);
            _context.next = 5;
            break;

          case 13:
            _context.prev = 13;
            _context.next = 16;
            return _awaitAsyncGenerator(asyncParallelEach(peekrs, function (peekr) {
              return peekr["return"]();
            }));

          case 16:
            return _context.finish(13);

          case 17:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[4,, 13, 17]]);
  }));
  return _asyncZip.apply(this, arguments);
}

var asyncZip = /*#__PURE__*/asyncIterableCurry(__asyncZip, {
  variadic: true
});
exports.asyncZip = asyncZip;
},{"../$map/async-map.js":337,"../$map/map.js":338,"../$peekerate/async-peekerate.js":339,"../$some/some.js":356,"../$to-array/async-to-array.js":398,"../../internal/async-iterable.js":480,"../../internal/async-parallel-each.js":481,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],413:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__zip);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var _require = require('../../internal/iterable.js'),
    iterableCurry = _require.iterableCurry;

var _require2 = require('../../internal/parallel-each.js'),
    parallelEach = _require2.parallelEach;

var _require3 = require('../$peekerate/peekerate.js'),
    __peekerate = _require3.__peekerate;

var _require4 = require('../$map/map.js'),
    __map = _require4.__map;

var _require5 = require('../$some/some.js'),
    __some = _require5.__some;

var _require6 = require('../$to-array/to-array.js'),
    __toArray = _require6.__toArray;

var isDone = function isDone(peekr) {
  return peekr.done;
};

function __zip(sources) {
  var peekrs, done, _iterator, _step, peekr;

  return _regeneratorRuntime.wrap(function __zip$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          peekrs = __toArray(__map(sources, __peekerate));
          done = __some(peekrs, isDone);
          _context.prev = 2;

        case 3:
          if (done) {
            _context.next = 11;
            break;
          }

          _context.next = 6;
          return peekrs.map(function (_ref) {
            var value = _ref.value;
            return value;
          });

        case 6:
          _iterator = _createForOfIteratorHelper(peekrs);

          try {
            for (_iterator.s(); !(_step = _iterator.n()).done;) {
              peekr = _step.value;
              peekr.advance();
            }
          } catch (err) {
            _iterator.e(err);
          } finally {
            _iterator.f();
          }

          done = __some(peekrs, isDone);
          _context.next = 3;
          break;

        case 11:
          _context.prev = 11;
          parallelEach(peekrs, function (peekr) {
            return peekr["return"]();
          });
          return _context.finish(11);

        case 14:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[2,, 11, 14]]);
}

exports.__zip = __zip;
var zip = /*#__PURE__*/iterableCurry(__zip, {
  variadic: true
});
exports.zip = zip;
},{"../$map/map.js":338,"../$peekerate/peekerate.js":340,"../$some/some.js":356,"../$to-array/to-array.js":399,"../../internal/iterable.js":493,"../../internal/parallel-each.js":495,"@babel/runtime/regenerator":65}],414:[function(require,module,exports){
var _toConsumableArray = require("@babel/runtime/helpers/toConsumableArray");

var _require = require('../../internal/curry.js'),
    curry = _require.curry;

function __apply(fn) {
  var args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
  return fn.apply(void 0, _toConsumableArray(args === null ? [] : args));
}

exports.__apply = __apply;
var apply = /*#__PURE__*/curry(__apply, 2);
exports.apply = apply;
},{"../../internal/curry.js":488,"@babel/runtime/helpers/toConsumableArray":61}],415:[function(require,module,exports){
function arrayFirstOr(whenEmpty, array) {
  return array && array.length ? array[0] : whenEmpty;
}

exports.arrayFirstOr = arrayFirstOr;
},{}],416:[function(require,module,exports){
function arrayFirst(array) {
  return array != null ? array[0] : undefined;
}

exports.arrayFirst = arrayFirst;
},{}],417:[function(require,module,exports){
exports.__arrayFromAsync = require('../$to-array/async-to-array.js').__asyncToArray;
exports.arrayFromAsync = require('../$to-array/async-to-array.js').asyncToArray;
},{"../$to-array/async-to-array.js":398}],418:[function(require,module,exports){
exports.__arrayFrom = require('../$to-array/to-array.js').__toArray;
exports.arrayFrom = require('../$to-array/to-array.js').toArray;
},{"../$to-array/to-array.js":399}],419:[function(require,module,exports){
function arrayLastOr(whenEmpty, array) {
  return array && array.length ? array[array.length - 1] : whenEmpty;
}

exports.arrayLastOr = arrayLastOr;
},{}],420:[function(require,module,exports){
function arrayLast(array) {
  return array ? array[array.length - 1] : undefined;
}

exports.arrayLast = arrayLast;
},{}],421:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__arrayReverse);

var _require = require('../../internal/iterable.js'),
    wrapWithIterableIterator = _require.wrapWithIterableIterator;

function __arrayReverse(source) {
  var i;
  return _regeneratorRuntime.wrap(function __arrayReverse$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          if (!(source == null)) {
            _context.next = 2;
            break;
          }

          return _context.abrupt("return");

        case 2:
          i = source.length - 1;

        case 3:
          if (!(i >= 0)) {
            _context.next = 9;
            break;
          }

          _context.next = 6;
          return source[i];

        case 6:
          i--;
          _context.next = 3;
          break;

        case 9:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

exports.__arrayReverse = __arrayReverse;
var arrayReverse = /*#__PURE__*/wrapWithIterableIterator(__arrayReverse, {
  validateArgs: function validateArgs(args) {
    if (!(Array.isArray(args[0]) || typeof args[0] === 'string' || args[0] == null)) {
      throw new Error('arrayReverse only works arrays and strings');
    }
  }
});
exports.arrayReverse = arrayReverse;
},{"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],422:[function(require,module,exports){
var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

var _createClass = require("@babel/runtime/helpers/createClass");

var _inherits = require("@babel/runtime/helpers/inherits");

var _possibleConstructorReturn = require("@babel/runtime/helpers/possibleConstructorReturn");

var _getPrototypeOf = require("@babel/runtime/helpers/getPrototypeOf");

var _regeneratorRuntime = require("@babel/runtime/regenerator");

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _require = require('../../internal/curry.js'),
    curry = _require.curry;

var _require2 = require('../../internal/async-iterable.js'),
    asyncCallReturn = _require2.asyncCallReturn;

var _require3 = require('../../internal/async-iterable-iterator.js'),
    AsyncIterableIterator = _require3.AsyncIterableIterator;

var _require4 = require('../../internal/circular-buffer.js'),
    CircularBuffer = _require4.CircularBuffer;

var _require5 = require('../../internal/number.js'),
    isPositiveInteger = _require5.isPositiveInteger;

var _require6 = require('../is-async-iterable/is-async-iterable.js'),
    isAsyncIterable = _require6.isAsyncIterable;

var _require7 = require('../../internal/iterable.js'),
    isIterable = _require7.isIterable;

function empty() {
  return _empty.apply(this, arguments);
}

function _empty() {
  _empty = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _empty.apply(this, arguments);
}

function getIterator(iterable) {
  if (iterable == null) {
    return empty();
  } else if (isAsyncIterable(iterable)) {
    return iterable[Symbol.asyncIterator]();
  } else if (isIterable(iterable)) {
    return iterable[Symbol.iterator]();
  } else {
    throw new Error("asyncBuffer expected an iterable but received ".concat(iterable, "."));
  }
}

var Bufferator = /*#__PURE__*/function (_AsyncIterableIterato) {
  _inherits(Bufferator, _AsyncIterableIterato);

  var _super = _createSuper(Bufferator);

  function Bufferator(iterable, concurrency) {
    var _this;

    _classCallCheck(this, Bufferator);

    _this = _super.call(this);
    _this.iterator = getIterator(iterable);
    _this.buffer = new CircularBuffer(concurrency);

    while (!_this.buffer.isFull()) {
      _this.buffer.push(Promise.resolve(_this.iterator.next()));
    }

    return _this;
  }

  _createClass(Bufferator, [{
    key: "next",
    value: function () {
      var _next = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
        var buffer, iterator;
        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                buffer = this.buffer, iterator = this.iterator;
                _context2.next = 3;
                return buffer.push(Promise.resolve(iterator.next()));

              case 3:
                return _context2.abrupt("return", _context2.sent);

              case 4:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function next() {
        return _next.apply(this, arguments);
      }

      return next;
    }()
  }, {
    key: "return",
    value: function () {
      var _return2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                _context3.next = 2;
                return asyncCallReturn(this.iterator);

              case 2:
                return _context3.abrupt("return", _context3.sent);

              case 3:
              case "end":
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      function _return() {
        return _return2.apply(this, arguments);
      }

      return _return;
    }()
  }]);

  return Bufferator;
}(AsyncIterableIterator);

exports.Bufferator = Bufferator;

function __asyncBuffer(source, n) {
  return new Bufferator(source, n);
}

exports.__asyncBuffer = __asyncBuffer;
var asyncBuffer = /*#__PURE__*/curry(function asyncBuffer(n, source) {
  if (n === undefined) return;

  if (n !== Infinity && !isPositiveInteger(n)) {
    throw new Error('Concurrency must be an integer > 0');
  } else if (n > 1024) {
    throw new Error('Concurrency argument to asyncBuffer must be <= 1024');
  }

  return __asyncBuffer(source, n);
});
exports.asyncBuffer = asyncBuffer;
},{"../../internal/async-iterable-iterator.js":479,"../../internal/async-iterable.js":480,"../../internal/circular-buffer.js":486,"../../internal/curry.js":488,"../../internal/iterable.js":493,"../../internal/number.js":494,"../is-async-iterable/is-async-iterable.js":433,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/createClass":47,"@babel/runtime/helpers/getPrototypeOf":50,"@babel/runtime/helpers/inherits":51,"@babel/runtime/helpers/possibleConstructorReturn":57,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],423:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('./internal/race-to.js'),
    raceTo = _require2.raceTo;

function __asyncInterleaveReady(_x) {
  return _asyncInterleaveReady.apply(this, arguments);
}

exports.__asyncInterleaveReady = __asyncInterleaveReady;

function _asyncInterleaveReady() {
  _asyncInterleaveReady = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(sources) {
    var iterators, stepPromises, ready, _loop;

    return _regeneratorRuntime.wrap(function _callee$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            iterators = sources.map(function (iterable) {
              return iterable[Symbol.asyncIterator]();
            });
            stepPromises = iterators.map(function (iter, idx) {
              return iter.next().then(function (step) {
                return {
                  idx: idx,
                  step: step
                };
              });
            });
            _loop = /*#__PURE__*/_regeneratorRuntime.mark(function _loop() {
              var _ready, idx, step;

              return _regeneratorRuntime.wrap(function _loop$(_context) {
                while (1) {
                  switch (_context.prev = _context.next) {
                    case 0:
                      _ready = ready, idx = _ready.idx, step = _ready.step;
                      _context.next = 3;
                      return step.value;

                    case 3:
                      stepPromises[idx] = iterators[idx].next().then(function (step) {
                        return {
                          idx: idx,
                          step: step
                        };
                      });

                    case 4:
                    case "end":
                      return _context.stop();
                  }
                }
              }, _loop);
            });

          case 3:
            _context2.next = 5;
            return _awaitAsyncGenerator(raceTo(function (_ref) {
              var step = _ref.step;
              return !step.done;
            }, null, stepPromises));

          case 5:
            _context2.t0 = ready = _context2.sent;

            if (!(_context2.t0 !== null)) {
              _context2.next = 10;
              break;
            }

            return _context2.delegateYield(_loop(), "t1", 8);

          case 8:
            _context2.next = 3;
            break;

          case 10:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee);
  }));
  return _asyncInterleaveReady.apply(this, arguments);
}

var asyncInterleaveReady = /*#__PURE__*/asyncIterableCurry(__asyncInterleaveReady, {
  variadic: true
});
exports.asyncInterleaveReady = asyncInterleaveReady;
},{"../../internal/async-iterable.js":480,"./internal/race-to.js":424,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],424:[function(require,module,exports){
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function raceTo(predicate, notFoundValue, promises) {
  return new Promise(function (resolve, reject) {
    var promiseCount = 0;
    var settledPromiseCount = 0;
    var resolved = false;
    var rejected = false;

    var _iterator = _createForOfIteratorHelper(promises),
        _step;

    try {
      for (_iterator.s(); !(_step = _iterator.n()).done;) {
        var promise = _step.value;
        promise["catch"](function (error) {
          if (!rejected && !resolved) {
            reject(error);
            rejected = true;
          }
        }).then(function (result) {
          settledPromiseCount++;

          if (!resolved && !rejected) {
            if (predicate(result)) {
              resolve(result);
              resolved = true;
            } else if (settledPromiseCount === promiseCount) {
              resolve(notFoundValue);
            }
          }
        });
        promiseCount++;
      }
    } catch (err) {
      _iterator.e(err);
    } finally {
      _iterator.f();
    }
  });
}

exports.raceTo = raceTo;
},{}],425:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../../internal/async-iterable.js'),
    asyncIterableCurry = _require.asyncIterableCurry;

var _require2 = require('../../internal/number.js'),
    isPositiveInteger = _require2.isPositiveInteger;

var _require3 = require('../../internal/delay.js'),
    delay = _require3.delay;

function __asyncThrottle(_x, _x2) {
  return _asyncThrottle.apply(this, arguments);
}

exports.__asyncThrottle = __asyncThrottle;

function _asyncThrottle() {
  _asyncThrottle = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, intervalMs) {
    var waitSince, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value, duration;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            waitSince = 0;
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context.prev = 3;
            _iterator = _asyncIterator(source);

          case 5:
            _context.next = 7;
            return _awaitAsyncGenerator(_iterator.next());

          case 7:
            _step = _context.sent;
            _iteratorNormalCompletion = _step.done;
            _context.next = 11;
            return _awaitAsyncGenerator(_step.value);

          case 11:
            _value = _context.sent;

            if (_iteratorNormalCompletion) {
              _context.next = 23;
              break;
            }

            value = _value;
            duration = intervalMs - (Date.now() - waitSince);
            _context.next = 17;
            return _awaitAsyncGenerator(duration > 0 && delay(duration));

          case 17:
            waitSince = Date.now();
            _context.next = 20;
            return value;

          case 20:
            _iteratorNormalCompletion = true;
            _context.next = 5;
            break;

          case 23:
            _context.next = 29;
            break;

          case 25:
            _context.prev = 25;
            _context.t0 = _context["catch"](3);
            _didIteratorError = true;
            _iteratorError = _context.t0;

          case 29:
            _context.prev = 29;
            _context.prev = 30;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context.next = 34;
              break;
            }

            _context.next = 34;
            return _awaitAsyncGenerator(_iterator["return"]());

          case 34:
            _context.prev = 34;

            if (!_didIteratorError) {
              _context.next = 37;
              break;
            }

            throw _iteratorError;

          case 37:
            return _context.finish(34);

          case 38:
            return _context.finish(29);

          case 39:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, null, [[3, 25, 29, 39], [30,, 34, 38]]);
  }));
  return _asyncThrottle.apply(this, arguments);
}

var asyncThrottle = /*#__PURE__*/asyncIterableCurry(__asyncThrottle, {
  validateArgs: function validateArgs(args) {
    if (!isPositiveInteger(args[1], true)) {
      throw new Error('intervalMs argument to asyncThrottle must be a number > 0');
    }
  }
});
exports.asyncThrottle = asyncThrottle;
},{"../../internal/async-iterable.js":480,"../../internal/delay.js":489,"../../internal/number.js":494,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],426:[function(require,module,exports){
function __call(fn) {
  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    args[_key - 1] = arguments[_key];
  }

  return fn.apply(void 0, args);
}

exports.__call = __call;
var call = __call;
exports.call = call;
},{}],427:[function(require,module,exports){
var identity = function identity(x) {
  return x;
};

function compose() {
  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
    fns[_key] = arguments[_key];
  }

  if (!fns.length) fns = [identity];
  return fns.reduce(function (f, g) {
    return function (x) {
      return f(g(x));
    };
  });
}

exports.compose = compose;
},{}],428:[function(require,module,exports){
function execPipe(initial) {
  for (var _len = arguments.length, fns = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    fns[_key - 1] = arguments[_key];
  }

  return fns.reduce(function (value, fn) {
    return fn(value);
  }, initial);
}

exports.execPipe = execPipe;
},{}],429:[function(require,module,exports){
function firstHighest(best, value) {
  return value > best;
}

exports.firstHighest = firstHighest;
},{}],430:[function(require,module,exports){
function firstLowest(best, value) {
  return value < best;
}

exports.firstLowest = firstLowest;
},{}],431:[function(require,module,exports){
function getSize(sequence) {
  if (sequence == null) {
    return 0;
  } else {
    var size = sequence.size;

    if (typeof size === 'number') {
      return sequence.size;
    } else if (Array.isArray(sequence)) {
      return sequence.length;
    }
  }

  throw new Error('The argument passed to getSize did not have a size');
}

exports.getSize = getSize;
},{}],432:[function(require,module,exports){
var isArray = Array.isArray;
exports.isArray = isArray;
},{}],433:[function(require,module,exports){
var _require = require('../not-undefined/not-undefined.js'),
    notUndefined = _require.notUndefined;

function isAsyncIterable(value) {
  return value != null && notUndefined(value[Symbol.asyncIterator]);
}

exports.isAsyncIterable = isAsyncIterable;
},{"../not-undefined/not-undefined.js":456}],434:[function(require,module,exports){
var _require = require('../not-undefined/not-undefined.js'),
    notUndefined = _require.notUndefined;

function isAsyncLoopable(value) {
  return value != null && (notUndefined(value[Symbol.asyncIterator]) || notUndefined(value[Symbol.iterator]));
}

exports.isAsyncLoopable = isAsyncLoopable;
},{"../not-undefined/not-undefined.js":456}],435:[function(require,module,exports){
var _require = require('../not-undefined/not-undefined.js'),
    notUndefined = _require.notUndefined;

function isAsyncWrappable(value) {
  return value == null || notUndefined(value[Symbol.asyncIterator]) || notUndefined(value[Symbol.iterator]);
}

exports.isAsyncWrappable = isAsyncWrappable;
},{"../not-undefined/not-undefined.js":456}],436:[function(require,module,exports){
var _require = require('../not-undefined/not-undefined.js'),
    notUndefined = _require.notUndefined;

function isIterable(value) {
  return value != null && notUndefined(value[Symbol.iterator]);
}

exports.isIterable = isIterable;
},{"../not-undefined/not-undefined.js":456}],437:[function(require,module,exports){
exports.isLoopable = require('../is-iterable/is-iterable.js').isIterable;
},{"../is-iterable/is-iterable.js":436}],438:[function(require,module,exports){
function isNil(value) {
  return value == null;
}

exports.isNil = isNil;
},{}],439:[function(require,module,exports){
function isNull(value) {
  return value === null;
}

exports.isNull = isNull;
},{}],440:[function(require,module,exports){
var _typeof = require("@babel/runtime/helpers/typeof");

function isObject(value) {
  return _typeof(value) === 'object' && value !== null;
}

exports.isObject = isObject;
},{"@babel/runtime/helpers/typeof":62}],441:[function(require,module,exports){
function isString(value) {
  return typeof value === 'string';
}

exports.isString = isString;
},{}],442:[function(require,module,exports){
function isUndefined(value) {
  return typeof value === 'undefined';
}

exports.isUndefined = isUndefined;
},{}],443:[function(require,module,exports){
var _require = require('../not-undefined/not-undefined.js'),
    notUndefined = _require.notUndefined;

function isWrappable(value) {
  return value == null || notUndefined(value[Symbol.iterator]);
}

exports.isWrappable = isWrappable;
},{"../not-undefined/not-undefined.js":456}],444:[function(require,module,exports){
function lastHighest(best, value) {
  return value >= best;
}

exports.lastHighest = lastHighest;
},{}],445:[function(require,module,exports){
function lastLowest(best, value) {
  return value <= best;
}

exports.lastLowest = lastLowest;
},{}],446:[function(require,module,exports){
var isArray = Array.isArray;

function notArray(value) {
  return !isArray(value);
}

exports.notArray = notArray;
},{}],447:[function(require,module,exports){
var _require = require('../is-undefined/is-undefined.js'),
    isUndefined = _require.isUndefined;

function notAsyncIterable(value) {
  return value == null || isUndefined(value[Symbol.asyncIterator]);
}

exports.notAsyncIterable = notAsyncIterable;
},{"../is-undefined/is-undefined.js":442}],448:[function(require,module,exports){
var _require = require('../is-undefined/is-undefined.js'),
    isUndefined = _require.isUndefined;

function notAsyncLoopable(value) {
  return value == null || isUndefined(value[Symbol.asyncIterator]) && isUndefined(value[Symbol.iterator]);
}

exports.notAsyncLoopable = notAsyncLoopable;
},{"../is-undefined/is-undefined.js":442}],449:[function(require,module,exports){
var _require = require('../is-undefined/is-undefined.js'),
    isUndefined = _require.isUndefined;

function notAsyncWrappable(value) {
  return value != null && isUndefined(value[Symbol.asyncIterator]) && isUndefined(value[Symbol.iterator]);
}

exports.notAsyncWrappable = notAsyncWrappable;
},{"../is-undefined/is-undefined.js":442}],450:[function(require,module,exports){
var _require = require('../is-undefined/is-undefined.js'),
    isUndefined = _require.isUndefined;

function notIterable(value) {
  return value == null || isUndefined(value[Symbol.iterator]);
}

exports.notIterable = notIterable;
},{"../is-undefined/is-undefined.js":442}],451:[function(require,module,exports){
exports.notLoopable = require('../not-iterable/not-iterable.js').notIterable;
},{"../not-iterable/not-iterable.js":450}],452:[function(require,module,exports){
function notNil(value) {
  return value != null;
}

exports.notNil = notNil;
},{}],453:[function(require,module,exports){
function notNull(value) {
  return value !== null;
}

exports.notNull = notNull;
},{}],454:[function(require,module,exports){
var _typeof = require("@babel/runtime/helpers/typeof");

function notObject(value) {
  return _typeof(value) !== 'object' || value === null;
}

exports.notObject = notObject;
},{"@babel/runtime/helpers/typeof":62}],455:[function(require,module,exports){
function notString(value) {
  return typeof value !== 'string';
}

exports.notString = notString;
},{}],456:[function(require,module,exports){
function notUndefined(value) {
  return typeof value !== 'undefined';
}

exports.notUndefined = notUndefined;
},{}],457:[function(require,module,exports){
var _require = require('../is-undefined/is-undefined.js'),
    isUndefined = _require.isUndefined;

function notWrappable(value) {
  return value != null && isUndefined(value[Symbol.iterator]);
}

exports.notWrappable = notWrappable;
},{"../is-undefined/is-undefined.js":442}],458:[function(require,module,exports){
var _typeof = require("@babel/runtime/helpers/typeof");

var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__objectEntries);

var _require = require('../../internal/iterable.js'),
    wrapWithIterableIterator = _require.wrapWithIterableIterator;

var hasOwnProperty = Object.prototype.hasOwnProperty;

function __objectEntries(obj) {
  var key;
  return _regeneratorRuntime.wrap(function __objectEntries$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          if (!(obj == null)) {
            _context.next = 2;
            break;
          }

          return _context.abrupt("return");

        case 2:
          _context.t0 = _regeneratorRuntime.keys(obj);

        case 3:
          if ((_context.t1 = _context.t0()).done) {
            _context.next = 10;
            break;
          }

          key = _context.t1.value;

          if (!hasOwnProperty.call(obj, key)) {
            _context.next = 8;
            break;
          }

          _context.next = 8;
          return [key, obj[key]];

        case 8:
          _context.next = 3;
          break;

        case 10:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

exports.__objectEntries = __objectEntries;
var objectEntries = /*#__PURE__*/wrapWithIterableIterator(__objectEntries, {
  validateArgs: function validateArgs(args) {
    if (!(args[0] == null || _typeof(args[0]) === 'object')) {
      throw new Error('obj argument to objectEntries must be an object, null, or undefined');
    }
  }
});
exports.objectEntries = objectEntries;
},{"../../internal/iterable.js":493,"@babel/runtime/helpers/typeof":62,"@babel/runtime/regenerator":65}],459:[function(require,module,exports){
exports.__objectFromAsync = require('../$to-object/async-to-object.js').__asyncToObject;
exports.objectFromAsync = require('../$to-object/async-to-object.js').asyncToObject;
},{"../$to-object/async-to-object.js":400}],460:[function(require,module,exports){
exports.__objectFrom = require('../$to-object/to-object.js').__toObject;
exports.objectFrom = require('../$to-object/to-object.js').toObject;
},{"../$to-object/to-object.js":401}],461:[function(require,module,exports){
var _typeof = require("@babel/runtime/helpers/typeof");

var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__objectKeys);

var _require = require('../../internal/iterable.js'),
    wrapWithIterableIterator = _require.wrapWithIterableIterator;

var hasOwnProperty = Object.prototype.hasOwnProperty;

function __objectKeys(obj) {
  var key;
  return _regeneratorRuntime.wrap(function __objectKeys$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          if (!(obj == null)) {
            _context.next = 2;
            break;
          }

          return _context.abrupt("return");

        case 2:
          _context.t0 = _regeneratorRuntime.keys(obj);

        case 3:
          if ((_context.t1 = _context.t0()).done) {
            _context.next = 10;
            break;
          }

          key = _context.t1.value;

          if (!hasOwnProperty.call(obj, key)) {
            _context.next = 8;
            break;
          }

          _context.next = 8;
          return key;

        case 8:
          _context.next = 3;
          break;

        case 10:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

exports.__objectKeys = __objectKeys;
var objectKeys = /*#__PURE__*/wrapWithIterableIterator(__objectKeys, {
  validateArgs: function validateArgs(args) {
    if (!(args[0] == null || _typeof(args[0]) === 'object')) {
      throw new Error('obj argument to objectKeys must be an object, null, or undefined');
    }
  }
});
exports.objectKeys = objectKeys;
},{"../../internal/iterable.js":493,"@babel/runtime/helpers/typeof":62,"@babel/runtime/regenerator":65}],462:[function(require,module,exports){
var _typeof = require("@babel/runtime/helpers/typeof");

var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__objectValues);

var _require = require('../../internal/iterable.js'),
    wrapWithIterableIterator = _require.wrapWithIterableIterator;

var hasOwnProperty = Object.prototype.hasOwnProperty;

function __objectValues(obj) {
  var key;
  return _regeneratorRuntime.wrap(function __objectValues$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          if (!(obj == null)) {
            _context.next = 2;
            break;
          }

          return _context.abrupt("return");

        case 2:
          _context.t0 = _regeneratorRuntime.keys(obj);

        case 3:
          if ((_context.t1 = _context.t0()).done) {
            _context.next = 10;
            break;
          }

          key = _context.t1.value;

          if (!hasOwnProperty.call(obj, key)) {
            _context.next = 8;
            break;
          }

          _context.next = 8;
          return obj[key];

        case 8:
          _context.next = 3;
          break;

        case 10:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

exports.__objectValues = __objectValues;
var objectValues = /*#__PURE__*/wrapWithIterableIterator(__objectValues, {
  validateArgs: function validateArgs(args) {
    if (!(args[0] == null || _typeof(args[0]) === 'object')) {
      throw new Error('obj argument to objectValues must be an object, null, or undefined');
    }
  }
});
exports.objectValues = objectValues;
},{"../../internal/iterable.js":493,"@babel/runtime/helpers/typeof":62,"@babel/runtime/regenerator":65}],463:[function(require,module,exports){
var identity = function identity(x) {
  return x;
};

function pipe() {
  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
    fns[_key] = arguments[_key];
  }

  if (!fns.length) fns = [identity];
  return fns.reduce(function (f, g) {
    return function () {
      return g(f.apply(void 0, arguments));
    };
  });
}

exports.pipe = pipe;
},{}],464:[function(require,module,exports){
var _slicedToArray = require("@babel/runtime/helpers/slicedToArray");

var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__range);

var _require = require('../../internal/iterable.js'),
    wrapWithIterableIterator = _require.wrapWithIterableIterator;

var _require2 = require('../../internal/number.js'),
    isInteger = _require2.isInteger,
    isIntegerOrInfinite = _require2.isIntegerOrInfinite;

var _require3 = require('../is-object/is-object.js'),
    isObject = _require3.isObject;

var _require4 = require('../not-undefined/not-undefined.js'),
    notUndefined = _require4.notUndefined;

function __range() {
  var start,
      end,
      step,
      i,
      _args = arguments;
  return _regeneratorRuntime.wrap(function __range$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          start = _args.length > 0 && _args[0] !== undefined ? _args[0] : 0;
          end = _args.length > 1 && _args[1] !== undefined ? _args[1] : Infinity;
          step = _args.length > 2 && _args[2] !== undefined ? _args[2] : 1;
          i = start;

        case 4:
          if (!(step > 0 ? i < end : i > end)) {
            _context.next = 10;
            break;
          }

          _context.next = 7;
          return i;

        case 7:
          i += step;
          _context.next = 4;
          break;

        case 10:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

exports.__range = __range;
var range = /*#__PURE__*/wrapWithIterableIterator(__range, {
  growRight: true,
  validateArgs: function validateArgs(args) {
    var _args2 = _slicedToArray(args, 3),
        optsOrEndOrStart = _args2[0],
        _args2$ = _args2[1],
        end = _args2$ === void 0 ? Infinity : _args2$,
        step = _args2[2];

    var start;

    if (isObject(optsOrEndOrStart)) {
      start = optsOrEndOrStart.start;
      end = optsOrEndOrStart.end;
      step = optsOrEndOrStart.step;
    } else {
      if (args.length > 1) {
        start = optsOrEndOrStart;
      } else {
        end = optsOrEndOrStart;
      }
    }

    if (notUndefined(start) && !isInteger(start)) {
      throw new TypeError('The specified start was not an integer');
    }

    if (notUndefined(end) && !isIntegerOrInfinite(end)) {
      throw new TypeError('The specified end was not an integer or infinite');
    }

    if (notUndefined(step) && !isInteger(step, true)) {
      throw new TypeError('The specified step was not a non-zero integer');
    }

    args[0] = start;
    args[1] = end;
    args[2] = step;
  }
});
exports.range = range;
},{"../../internal/iterable.js":493,"../../internal/number.js":494,"../is-object/is-object.js":440,"../not-undefined/not-undefined.js":456,"@babel/runtime/helpers/slicedToArray":59,"@babel/runtime/regenerator":65}],465:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__repeatTimes);

var _require = require('../../internal/curry.js'),
    curry = _require.curry;

var _require2 = require('../../internal/iterable.js'),
    wrapWithIterableIterator = _require2.wrapWithIterableIterator;

function __repeatTimes(n, value) {
  return _regeneratorRuntime.wrap(function __repeatTimes$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          if (!n--) {
            _context.next = 5;
            break;
          }

          _context.next = 3;
          return value;

        case 3:
          _context.next = 0;
          break;

        case 5:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

exports.__repeatTimes = __repeatTimes;
var repeatTimes = /*#__PURE__*/curry( /*#__PURE__*/wrapWithIterableIterator(__repeatTimes), __repeatTimes.length);
exports.repeatTimes = repeatTimes;
},{"../../internal/curry.js":488,"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],466:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__repeat);

var _require = require('../../internal/iterable.js'),
    wrapWithIterableIterator = _require.wrapWithIterableIterator;

function __repeat(value) {
  return _regeneratorRuntime.wrap(function __repeat$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          if (!true) {
            _context.next = 5;
            break;
          }

          _context.next = 3;
          return value;

        case 3:
          _context.next = 0;
          break;

        case 5:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

exports.__repeat = __repeat;
var repeat = /*#__PURE__*/wrapWithIterableIterator(__repeat);
exports.repeat = repeat;
},{"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],467:[function(require,module,exports){
exports.__stringFromAsync = require('../$str/async-str.js').__asyncStr;
exports.stringFromAsync = require('../$str/async-str.js').asyncStr;
},{"../$str/async-str.js":383}],468:[function(require,module,exports){
exports.__stringFrom = require('../$str/str.js').__str;
exports.stringFrom = require('../$str/str.js').str;
},{"../$str/str.js":384}],469:[function(require,module,exports){
var _typeof = require("@babel/runtime/helpers/typeof");

var _defineProperty = require("@babel/runtime/helpers/defineProperty");

var emptyIterator = {
  next: function next() {
    return {
      value: undefined,
      done: true
    };
  }
};
var emptySpreadable = Object.freeze(Object.create(_defineProperty({}, Symbol.iterator, function () {
  return emptyIterator;
})));

function when(condition, value) {
  var valueType = _typeof(value);

  if (!(value == null || value[Symbol.iterator] || valueType === 'object' || valueType === 'function')) {
    throw new Error('Second argument to when must be an object, iterable, or function.');
  }

  return condition && value != null ? valueType === 'function' ? value() : value : emptySpreadable;
}

exports.when = when;
},{"@babel/runtime/helpers/defineProperty":48,"@babel/runtime/helpers/typeof":62}],470:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__wrapEntries);

var _require = require('../../internal/iterable.js'),
    wrapWithIterableIterator = _require.wrapWithIterableIterator;

function __wrapEntries(entriesable) {
  return _regeneratorRuntime.wrap(function __wrapEntries$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          if (!(entriesable != null)) {
            _context.next = 2;
            break;
          }

          return _context.delegateYield(entriesable.entries(), "t0", 2);

        case 2:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

exports.__wrapEntries = __wrapEntries;
var wrapEntries = /*#__PURE__*/wrapWithIterableIterator(__wrapEntries);
exports.wrapEntries = wrapEntries;
},{"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],471:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__wrapKeys);

var _require = require('../../internal/iterable.js'),
    wrapWithIterableIterator = _require.wrapWithIterableIterator;

function __wrapKeys(keysable) {
  return _regeneratorRuntime.wrap(function __wrapKeys$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          if (!(keysable != null)) {
            _context.next = 2;
            break;
          }

          return _context.delegateYield(keysable.keys(), "t0", 2);

        case 2:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

exports.__wrapKeys = __wrapKeys;
var wrapKeys = /*#__PURE__*/wrapWithIterableIterator(__wrapKeys);
exports.wrapKeys = wrapKeys;
},{"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],472:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(__wrapValues);

var _require = require('../../internal/iterable.js'),
    wrapWithIterableIterator = _require.wrapWithIterableIterator;

function __wrapValues(valuesable) {
  return _regeneratorRuntime.wrap(function __wrapValues$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          if (!(valuesable != null)) {
            _context.next = 2;
            break;
          }

          return _context.delegateYield(valuesable.values(), "t0", 2);

        case 2:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

exports.__wrapValues = __wrapValues;
var wrapValues = /*#__PURE__*/wrapWithIterableIterator(__wrapValues);
exports.wrapValues = wrapValues;
},{"../../internal/iterable.js":493,"@babel/runtime/regenerator":65}],473:[function(require,module,exports){
exports.__append = require('./__methods/append.js');
exports.__apply = require('./__methods/apply.js');
exports.__arrayReverse = require('./__methods/array-reverse.js');
exports.__asyncAppend = require('./__methods/async-append.js');
exports.__asyncBatch = require('./__methods/async-batch.js');
exports.__asyncBisect = require('./__methods/async-bisect.js');
exports.__asyncBuffer = require('./__methods/async-buffer.js');
exports.__asyncCollate = require('./__methods/async-collate.js');
exports.__asyncCompress = require('./__methods/async-compress.js');
exports.__asyncConcat = require('./__methods/async-concat.js');
exports.__asyncConsume = require('./__methods/async-consume.js');
exports.__asyncCycle = require('./__methods/async-cycle.js');
exports.__asyncCycleTimes = require('./__methods/async-cycle-times.js');
exports.__asyncDeepEqual = require('./__methods/async-deep-equal.js');
exports.__asyncDistinct = require('./__methods/async-distinct.js');
exports.__asyncDrop = require('./__methods/async-drop.js');
exports.__asyncDropWhile = require('./__methods/async-drop-while.js');
exports.__asyncEnumerate = require('./__methods/async-enumerate.js');
exports.__asyncEqual = require('./__methods/async-equal.js');
exports.__asyncEvery = require('./__methods/async-every.js');
exports.__asyncFilter = require('./__methods/async-filter.js');
exports.__asyncFind = require('./__methods/async-find.js');
exports.__asyncFindBest = require('./__methods/async-find-best.js');
exports.__asyncFindBestOr = require('./__methods/async-find-best-or.js');
exports.__asyncFindOr = require('./__methods/async-find-or.js');
exports.__asyncFirst = require('./__methods/async-first.js');
exports.__asyncFirstOr = require('./__methods/async-first-or.js');
exports.__asyncFlat = require('./__methods/async-flat.js');
exports.__asyncFlatMap = require('./__methods/async-flat-map.js');
exports.__asyncForEach = require('./__methods/async-for-each.js');
exports.__asyncFork = require('./__methods/async-fork.js');
exports.__asyncForkerate = require('./__methods/async-forkerate.js');
exports.__asyncIncludes = require('./__methods/async-includes.js');
exports.__asyncIncludesAny = require('./__methods/async-includes-any.js');
exports.__asyncIncludesAnySeq = require('./__methods/async-includes-any-seq.js');
exports.__asyncIncludesSeq = require('./__methods/async-includes-seq.js');
exports.__asyncInterleave = require('./__methods/async-interleave.js');
exports.__asyncInterleaveReady = require('./__methods/async-interleave-ready.js');
exports.__asyncInterpose = require('./__methods/async-interpose.js');
exports.__asyncInterposeSeq = require('./__methods/async-interpose-seq.js');
exports.__asyncIsEmpty = require('./__methods/async-is-empty.js');
exports.__asyncIsSorted = require('./__methods/async-is-sorted.js');
exports.__asyncJoin = require('./__methods/async-join.js');
exports.__asyncJoinWith = require('./__methods/async-join-with.js');
exports.__asyncJoinWithSeq = require('./__methods/async-join-with-seq.js');
exports.__asyncMap = require('./__methods/async-map.js');
exports.__asyncPeekerate = require('./__methods/async-peekerate.js');
exports.__asyncPrepend = require('./__methods/async-prepend.js');
exports.__asyncReduce = require('./__methods/async-reduce.js');
exports.__asyncReverse = require('./__methods/async-reverse.js');
exports.__asyncRoundRobin = require('./__methods/async-round-robin.js');
exports.__asyncSize = require('./__methods/async-size.js');
exports.__asyncSlice = require('./__methods/async-slice.js');
exports.__asyncSome = require('./__methods/async-some.js');
exports.__asyncSplit = require('./__methods/async-split.js');
exports.__asyncSplitGroups = require('./__methods/async-split-groups.js');
exports.__asyncSplitOn = require('./__methods/async-split-on.js');
exports.__asyncSplitOnAny = require('./__methods/async-split-on-any.js');
exports.__asyncSplitOnAnySeq = require('./__methods/async-split-on-any-seq.js');
exports.__asyncSplitOnSeq = require('./__methods/async-split-on-seq.js');
exports.__asyncSplitWhen = require('./__methods/async-split-when.js');
exports.__asyncSpliterate = require('./__methods/async-spliterate.js');
exports.__asyncSpliterateGrouped = require('./__methods/async-spliterate-grouped.js');
exports.__asyncStartsWith = require('./__methods/async-starts-with.js');
exports.__asyncStartsWithAny = require('./__methods/async-starts-with-any.js');
exports.__asyncStartsWithAnySeq = require('./__methods/async-starts-with-any-seq.js');
exports.__asyncStartsWithSeq = require('./__methods/async-starts-with-seq.js');
exports.__asyncStr = require('./__methods/async-str.js');
exports.__asyncTake = require('./__methods/async-take.js');
exports.__asyncTakeLast = require('./__methods/async-take-last.js');
exports.__asyncTakeLastOr = require('./__methods/async-take-last-or.js');
exports.__asyncTakeSorted = require('./__methods/async-take-sorted.js');
exports.__asyncTakeWhile = require('./__methods/async-take-while.js');
exports.__asyncTap = require('./__methods/async-tap.js');
exports.__asyncThrottle = require('./__methods/async-throttle.js');
exports.__asyncToArray = require('./__methods/async-to-array.js');
exports.__asyncToObject = require('./__methods/async-to-object.js');
exports.__asyncWindow = require('./__methods/async-window.js');
exports.__asyncWindowAhead = require('./__methods/async-window-ahead.js');
exports.__asyncWindowBehind = require('./__methods/async-window-behind.js');
exports.__asyncZip = require('./__methods/async-zip.js');
exports.__asyncZipAll = require('./__methods/async-zip-all.js');
exports.__batch = require('./__methods/batch.js');
exports.__bisect = require('./__methods/bisect.js');
exports.__call = require('./__methods/call.js');
exports.__collate = require('./__methods/collate.js');
exports.__compress = require('./__methods/compress.js');
exports.__concat = require('./__methods/concat.js');
exports.__consume = require('./__methods/consume.js');
exports.__cycle = require('./__methods/cycle.js');
exports.__cycleTimes = require('./__methods/cycle-times.js');
exports.__deepEqual = require('./__methods/deep-equal.js');
exports.__distinct = require('./__methods/distinct.js');
exports.__drop = require('./__methods/drop.js');
exports.__dropWhile = require('./__methods/drop-while.js');
exports.__enumerate = require('./__methods/enumerate.js');
exports.__equal = require('./__methods/equal.js');
exports.__every = require('./__methods/every.js');
exports.__filter = require('./__methods/filter.js');
exports.__find = require('./__methods/find.js');
exports.__findBest = require('./__methods/find-best.js');
exports.__findBestOr = require('./__methods/find-best-or.js');
exports.__findOr = require('./__methods/find-or.js');
exports.__first = require('./__methods/first.js');
exports.__firstOr = require('./__methods/first-or.js');
exports.__flat = require('./__methods/flat.js');
exports.__flatMap = require('./__methods/flat-map.js');
exports.__forEach = require('./__methods/for-each.js');
exports.__fork = require('./__methods/fork.js');
exports.__forkerate = require('./__methods/forkerate.js');
exports.__includes = require('./__methods/includes.js');
exports.__includesAny = require('./__methods/includes-any.js');
exports.__includesAnySeq = require('./__methods/includes-any-seq.js');
exports.__includesSeq = require('./__methods/includes-seq.js');
exports.__interleave = require('./__methods/interleave.js');
exports.__interpose = require('./__methods/interpose.js');
exports.__interposeSeq = require('./__methods/interpose-seq.js');
exports.__isEmpty = require('./__methods/is-empty.js');
exports.__isSorted = require('./__methods/is-sorted.js');
exports.__join = require('./__methods/join.js');
exports.__joinWith = require('./__methods/join-with.js');
exports.__joinWithSeq = require('./__methods/join-with-seq.js');
exports.__map = require('./__methods/map.js');
exports.__objectEntries = require('./__methods/object-entries.js');
exports.__objectKeys = require('./__methods/object-keys.js');
exports.__objectValues = require('./__methods/object-values.js');
exports.__peekerate = require('./__methods/peekerate.js');
exports.__prepend = require('./__methods/prepend.js');
exports.__range = require('./__methods/range.js');
exports.__reduce = require('./__methods/reduce.js');
exports.__repeat = require('./__methods/repeat.js');
exports.__repeatTimes = require('./__methods/repeat-times.js');
exports.__reverse = require('./__methods/reverse.js');
exports.__roundRobin = require('./__methods/round-robin.js');
exports.__size = require('./__methods/size.js');
exports.__slice = require('./__methods/slice.js');
exports.__some = require('./__methods/some.js');
exports.__split = require('./__methods/split.js');
exports.__splitGroups = require('./__methods/split-groups.js');
exports.__splitOn = require('./__methods/split-on.js');
exports.__splitOnAny = require('./__methods/split-on-any.js');
exports.__splitOnAnySeq = require('./__methods/split-on-any-seq.js');
exports.__splitOnSeq = require('./__methods/split-on-seq.js');
exports.__splitWhen = require('./__methods/split-when.js');
exports.__spliterate = require('./__methods/spliterate.js');
exports.__spliterateGrouped = require('./__methods/spliterate-grouped.js');
exports.__startsWith = require('./__methods/starts-with.js');
exports.__startsWithAny = require('./__methods/starts-with-any.js');
exports.__startsWithAnySeq = require('./__methods/starts-with-any-seq.js');
exports.__startsWithSeq = require('./__methods/starts-with-seq.js');
exports.__str = require('./__methods/str.js');
exports.__take = require('./__methods/take.js');
exports.__takeLast = require('./__methods/take-last.js');
exports.__takeLastOr = require('./__methods/take-last-or.js');
exports.__takeSorted = require('./__methods/take-sorted.js');
exports.__takeWhile = require('./__methods/take-while.js');
exports.__tap = require('./__methods/tap.js');
exports.__toArray = require('./__methods/to-array.js');
exports.__toObject = require('./__methods/to-object.js');
exports.__window = require('./__methods/window.js');
exports.__windowAhead = require('./__methods/window-ahead.js');
exports.__windowBehind = require('./__methods/window-behind.js');
exports.__wrapEntries = require('./__methods/wrap-entries.js');
exports.__wrapKeys = require('./__methods/wrap-keys.js');
exports.__wrapValues = require('./__methods/wrap-values.js');
exports.__zip = require('./__methods/zip.js');
exports.__zipAll = require('./__methods/zip-all.js');
exports.append = require('./methods/append.js');
exports.apply = require('./methods/apply.js');
exports.arrayFirst = require('./methods/array-first.js');
exports.arrayFirstOr = require('./methods/array-first-or.js');
exports.arrayFrom = require('./methods/array-from.js');
exports.arrayFromAsync = require('./methods/array-from-async.js');
exports.arrayLast = require('./methods/array-last.js');
exports.arrayLastOr = require('./methods/array-last-or.js');
exports.arrayReverse = require('./methods/array-reverse.js');
exports.batch = require('./methods/batch.js');
exports.bisect = require('./methods/bisect.js');
exports.call = require('./methods/call.js');
exports.collate = require('./methods/collate.js');
exports.compose = require('./methods/compose.js');
exports.compress = require('./methods/compress.js');
exports.concat = require('./methods/concat.js');
exports.consume = require('./methods/consume.js');
exports.cycle = require('./methods/cycle.js');
exports.cycleTimes = require('./methods/cycle-times.js');
exports.deepEqual = require('./methods/deep-equal.js');
exports.distinct = require('./methods/distinct.js');
exports.drop = require('./methods/drop.js');
exports.dropWhile = require('./methods/drop-while.js');
exports.enumerate = require('./methods/enumerate.js');
exports.equal = require('./methods/equal.js');
exports.every = require('./methods/every.js');
exports.execPipe = require('./methods/exec-pipe.js');
exports.filter = require('./methods/filter.js');
exports.find = require('./methods/find.js');
exports.findBest = require('./methods/find-best.js');
exports.findBestOr = require('./methods/find-best-or.js');
exports.findOr = require('./methods/find-or.js');
exports.first = require('./methods/first.js');
exports.firstHighest = require('./methods/first-highest.js');
exports.firstLowest = require('./methods/first-lowest.js');
exports.firstOr = require('./methods/first-or.js');
exports.flat = require('./methods/flat.js');
exports.flatMap = require('./methods/flat-map.js');
exports.forEach = require('./methods/for-each.js');
exports.fork = require('./methods/fork.js');
exports.forkerate = require('./methods/forkerate.js');
exports.getSize = require('./methods/get-size.js');
exports.includes = require('./methods/includes.js');
exports.includesAny = require('./methods/includes-any.js');
exports.includesAnySeq = require('./methods/includes-any-seq.js');
exports.includesSeq = require('./methods/includes-seq.js');
exports.interleave = require('./methods/interleave.js');
exports.interpose = require('./methods/interpose.js');
exports.interposeSeq = require('./methods/interpose-seq.js');
exports.isArray = require('./methods/is-array.js');
exports.isAsyncIterable = require('./methods/is-async-iterable.js');
exports.isAsyncLoopable = require('./methods/is-async-loopable.js');
exports.isAsyncWrappable = require('./methods/is-async-wrappable.js');
exports.isEmpty = require('./methods/is-empty.js');
exports.isIterable = require('./methods/is-iterable.js');
exports.isLoopable = require('./methods/is-loopable.js');
exports.isNil = require('./methods/is-nil.js');
exports.isNull = require('./methods/is-null.js');
exports.isObject = require('./methods/is-object.js');
exports.isSorted = require('./methods/is-sorted.js');
exports.isString = require('./methods/is-string.js');
exports.isUndefined = require('./methods/is-undefined.js');
exports.isWrappable = require('./methods/is-wrappable.js');
exports.join = require('./methods/join.js');
exports.joinWith = require('./methods/join-with.js');
exports.joinWithSeq = require('./methods/join-with-seq.js');
exports.lastHighest = require('./methods/last-highest.js');
exports.lastLowest = require('./methods/last-lowest.js');
exports.map = require('./methods/map.js');
exports.notArray = require('./methods/not-array.js');
exports.notAsyncIterable = require('./methods/not-async-iterable.js');
exports.notAsyncLoopable = require('./methods/not-async-loopable.js');
exports.notAsyncWrappable = require('./methods/not-async-wrappable.js');
exports.notIterable = require('./methods/not-iterable.js');
exports.notLoopable = require('./methods/not-loopable.js');
exports.notNil = require('./methods/not-nil.js');
exports.notNull = require('./methods/not-null.js');
exports.notObject = require('./methods/not-object.js');
exports.notString = require('./methods/not-string.js');
exports.notUndefined = require('./methods/not-undefined.js');
exports.notWrappable = require('./methods/not-wrappable.js');
exports.objectEntries = require('./methods/object-entries.js');
exports.objectFrom = require('./methods/object-from.js');
exports.objectFromAsync = require('./methods/object-from-async.js');
exports.objectKeys = require('./methods/object-keys.js');
exports.objectValues = require('./methods/object-values.js');
exports.peekerate = require('./methods/peekerate.js');
exports.pipe = require('./methods/pipe.js');
exports.prepend = require('./methods/prepend.js');
exports.range = require('./methods/range.js');
exports.reduce = require('./methods/reduce.js');
exports.repeat = require('./methods/repeat.js');
exports.repeatTimes = require('./methods/repeat-times.js');
exports.reverse = require('./methods/reverse.js');
exports.roundRobin = require('./methods/round-robin.js');
exports.size = require('./methods/size.js');
exports.slice = require('./methods/slice.js');
exports.some = require('./methods/some.js');
exports.split = require('./methods/split.js');
exports.splitGroups = require('./methods/split-groups.js');
exports.splitOn = require('./methods/split-on.js');
exports.splitOnAny = require('./methods/split-on-any.js');
exports.splitOnAnySeq = require('./methods/split-on-any-seq.js');
exports.splitOnSeq = require('./methods/split-on-seq.js');
exports.splitWhen = require('./methods/split-when.js');
exports.spliterate = require('./methods/spliterate.js');
exports.spliterateGrouped = require('./methods/spliterate-grouped.js');
exports.startsWith = require('./methods/starts-with.js');
exports.startsWithAny = require('./methods/starts-with-any.js');
exports.startsWithAnySeq = require('./methods/starts-with-any-seq.js');
exports.startsWithSeq = require('./methods/starts-with-seq.js');
exports.str = require('./methods/str.js');
exports.stringFrom = require('./methods/string-from.js');
exports.stringFromAsync = require('./methods/string-from-async.js');
exports.take = require('./methods/take.js');
exports.takeLast = require('./methods/take-last.js');
exports.takeLastOr = require('./methods/take-last-or.js');
exports.takeSorted = require('./methods/take-sorted.js');
exports.takeWhile = require('./methods/take-while.js');
exports.tap = require('./methods/tap.js');
exports.toArray = require('./methods/to-array.js');
exports.toObject = require('./methods/to-object.js');
exports.when = require('./methods/when.js');
exports.window = require('./methods/window.js');
exports.windowAhead = require('./methods/window-ahead.js');
exports.windowBehind = require('./methods/window-behind.js');
exports.wrap = require('./methods/wrap.js');
exports.wrapEntries = require('./methods/wrap-entries.js');
exports.wrapKeys = require('./methods/wrap-keys.js');
exports.wrapValues = require('./methods/wrap-values.js');
exports.zip = require('./methods/zip.js');
exports.zipAll = require('./methods/zip-all.js');
exports.asyncAppend = require('./methods/async-append.js');
exports.asyncBatch = require('./methods/async-batch.js');
exports.asyncBisect = require('./methods/async-bisect.js');
exports.asyncBuffer = require('./methods/async-buffer.js');
exports.asyncCollate = require('./methods/async-collate.js');
exports.asyncCompress = require('./methods/async-compress.js');
exports.asyncConcat = require('./methods/async-concat.js');
exports.asyncConsume = require('./methods/async-consume.js');
exports.asyncCycle = require('./methods/async-cycle.js');
exports.asyncCycleTimes = require('./methods/async-cycle-times.js');
exports.asyncDeepEqual = require('./methods/async-deep-equal.js');
exports.asyncDistinct = require('./methods/async-distinct.js');
exports.asyncDrop = require('./methods/async-drop.js');
exports.asyncDropWhile = require('./methods/async-drop-while.js');
exports.asyncEnumerate = require('./methods/async-enumerate.js');
exports.asyncEqual = require('./methods/async-equal.js');
exports.asyncEvery = require('./methods/async-every.js');
exports.asyncFilter = require('./methods/async-filter.js');
exports.asyncFind = require('./methods/async-find.js');
exports.asyncFindBest = require('./methods/async-find-best.js');
exports.asyncFindBestOr = require('./methods/async-find-best-or.js');
exports.asyncFindOr = require('./methods/async-find-or.js');
exports.asyncFirst = require('./methods/async-first.js');
exports.asyncFirstOr = require('./methods/async-first-or.js');
exports.asyncFlat = require('./methods/async-flat.js');
exports.asyncFlatMap = require('./methods/async-flat-map.js');
exports.asyncForEach = require('./methods/async-for-each.js');
exports.asyncFork = require('./methods/async-fork.js');
exports.asyncForkerate = require('./methods/async-forkerate.js');
exports.asyncIncludes = require('./methods/async-includes.js');
exports.asyncIncludesAny = require('./methods/async-includes-any.js');
exports.asyncIncludesAnySeq = require('./methods/async-includes-any-seq.js');
exports.asyncIncludesSeq = require('./methods/async-includes-seq.js');
exports.asyncInterleave = require('./methods/async-interleave.js');
exports.asyncInterleaveReady = require('./methods/async-interleave-ready.js');
exports.asyncInterpose = require('./methods/async-interpose.js');
exports.asyncInterposeSeq = require('./methods/async-interpose-seq.js');
exports.asyncIsEmpty = require('./methods/async-is-empty.js');
exports.asyncIsSorted = require('./methods/async-is-sorted.js');
exports.asyncJoin = require('./methods/async-join.js');
exports.asyncJoinWith = require('./methods/async-join-with.js');
exports.asyncJoinWithSeq = require('./methods/async-join-with-seq.js');
exports.asyncMap = require('./methods/async-map.js');
exports.asyncPeekerate = require('./methods/async-peekerate.js');
exports.asyncPrepend = require('./methods/async-prepend.js');
exports.asyncReduce = require('./methods/async-reduce.js');
exports.asyncReverse = require('./methods/async-reverse.js');
exports.asyncRoundRobin = require('./methods/async-round-robin.js');
exports.asyncSize = require('./methods/async-size.js');
exports.asyncSlice = require('./methods/async-slice.js');
exports.asyncSome = require('./methods/async-some.js');
exports.asyncSplit = require('./methods/async-split.js');
exports.asyncSplitGroups = require('./methods/async-split-groups.js');
exports.asyncSplitOn = require('./methods/async-split-on.js');
exports.asyncSplitOnAny = require('./methods/async-split-on-any.js');
exports.asyncSplitOnAnySeq = require('./methods/async-split-on-any-seq.js');
exports.asyncSplitOnSeq = require('./methods/async-split-on-seq.js');
exports.asyncSplitWhen = require('./methods/async-split-when.js');
exports.asyncSpliterate = require('./methods/async-spliterate.js');
exports.asyncSpliterateGrouped = require('./methods/async-spliterate-grouped.js');
exports.asyncStartsWith = require('./methods/async-starts-with.js');
exports.asyncStartsWithAny = require('./methods/async-starts-with-any.js');
exports.asyncStartsWithAnySeq = require('./methods/async-starts-with-any-seq.js');
exports.asyncStartsWithSeq = require('./methods/async-starts-with-seq.js');
exports.asyncStr = require('./methods/async-str.js');
exports.asyncTake = require('./methods/async-take.js');
exports.asyncTakeLast = require('./methods/async-take-last.js');
exports.asyncTakeLastOr = require('./methods/async-take-last-or.js');
exports.asyncTakeSorted = require('./methods/async-take-sorted.js');
exports.asyncTakeWhile = require('./methods/async-take-while.js');
exports.asyncTap = require('./methods/async-tap.js');
exports.asyncThrottle = require('./methods/async-throttle.js');
exports.asyncToArray = require('./methods/async-to-array.js');
exports.asyncToObject = require('./methods/async-to-object.js');
exports.asyncWindow = require('./methods/async-window.js');
exports.asyncWindowAhead = require('./methods/async-window-ahead.js');
exports.asyncWindowBehind = require('./methods/async-window-behind.js');
exports.asyncWrap = require('./methods/async-wrap.js');
exports.asyncZip = require('./methods/async-zip.js');
exports.asyncZipAll = require('./methods/async-zip-all.js');
},{"./__methods/append.js":89,"./__methods/apply.js":90,"./__methods/array-reverse.js":91,"./__methods/async-append.js":92,"./__methods/async-batch.js":93,"./__methods/async-bisect.js":94,"./__methods/async-buffer.js":95,"./__methods/async-collate.js":96,"./__methods/async-compress.js":97,"./__methods/async-concat.js":98,"./__methods/async-consume.js":99,"./__methods/async-cycle-times.js":100,"./__methods/async-cycle.js":101,"./__methods/async-deep-equal.js":102,"./__methods/async-distinct.js":103,"./__methods/async-drop-while.js":104,"./__methods/async-drop.js":105,"./__methods/async-enumerate.js":106,"./__methods/async-equal.js":107,"./__methods/async-every.js":108,"./__methods/async-filter.js":109,"./__methods/async-find-best-or.js":110,"./__methods/async-find-best.js":111,"./__methods/async-find-or.js":112,"./__methods/async-find.js":113,"./__methods/async-first-or.js":114,"./__methods/async-first.js":115,"./__methods/async-flat-map.js":116,"./__methods/async-flat.js":117,"./__methods/async-for-each.js":118,"./__methods/async-fork.js":119,"./__methods/async-forkerate.js":120,"./__methods/async-includes-any-seq.js":121,"./__methods/async-includes-any.js":122,"./__methods/async-includes-seq.js":123,"./__methods/async-includes.js":124,"./__methods/async-interleave-ready.js":125,"./__methods/async-interleave.js":126,"./__methods/async-interpose-seq.js":127,"./__methods/async-interpose.js":128,"./__methods/async-is-empty.js":129,"./__methods/async-is-sorted.js":130,"./__methods/async-join-with-seq.js":131,"./__methods/async-join-with.js":132,"./__methods/async-join.js":133,"./__methods/async-map.js":134,"./__methods/async-peekerate.js":135,"./__methods/async-prepend.js":136,"./__methods/async-reduce.js":137,"./__methods/async-reverse.js":138,"./__methods/async-round-robin.js":139,"./__methods/async-size.js":140,"./__methods/async-slice.js":141,"./__methods/async-some.js":142,"./__methods/async-split-groups.js":143,"./__methods/async-split-on-any-seq.js":144,"./__methods/async-split-on-any.js":145,"./__methods/async-split-on-seq.js":146,"./__methods/async-split-on.js":147,"./__methods/async-split-when.js":148,"./__methods/async-split.js":149,"./__methods/async-spliterate-grouped.js":150,"./__methods/async-spliterate.js":151,"./__methods/async-starts-with-any-seq.js":152,"./__methods/async-starts-with-any.js":153,"./__methods/async-starts-with-seq.js":154,"./__methods/async-starts-with.js":155,"./__methods/async-str.js":156,"./__methods/async-take-last-or.js":157,"./__methods/async-take-last.js":158,"./__methods/async-take-sorted.js":159,"./__methods/async-take-while.js":160,"./__methods/async-take.js":161,"./__methods/async-tap.js":162,"./__methods/async-throttle.js":163,"./__methods/async-to-array.js":164,"./__methods/async-to-object.js":165,"./__methods/async-window-ahead.js":166,"./__methods/async-window-behind.js":167,"./__methods/async-window.js":168,"./__methods/async-zip-all.js":169,"./__methods/async-zip.js":170,"./__methods/batch.js":171,"./__methods/bisect.js":172,"./__methods/call.js":173,"./__methods/collate.js":174,"./__methods/compress.js":175,"./__methods/concat.js":176,"./__methods/consume.js":177,"./__methods/cycle-times.js":178,"./__methods/cycle.js":179,"./__methods/deep-equal.js":180,"./__methods/distinct.js":181,"./__methods/drop-while.js":182,"./__methods/drop.js":183,"./__methods/enumerate.js":184,"./__methods/equal.js":185,"./__methods/every.js":186,"./__methods/filter.js":187,"./__methods/find-best-or.js":188,"./__methods/find-best.js":189,"./__methods/find-or.js":190,"./__methods/find.js":191,"./__methods/first-or.js":192,"./__methods/first.js":193,"./__methods/flat-map.js":194,"./__methods/flat.js":195,"./__methods/for-each.js":196,"./__methods/fork.js":197,"./__methods/forkerate.js":198,"./__methods/includes-any-seq.js":199,"./__methods/includes-any.js":200,"./__methods/includes-seq.js":201,"./__methods/includes.js":202,"./__methods/interleave.js":203,"./__methods/interpose-seq.js":204,"./__methods/interpose.js":205,"./__methods/is-empty.js":206,"./__methods/is-sorted.js":207,"./__methods/join-with-seq.js":208,"./__methods/join-with.js":209,"./__methods/join.js":210,"./__methods/map.js":211,"./__methods/object-entries.js":212,"./__methods/object-keys.js":213,"./__methods/object-values.js":214,"./__methods/peekerate.js":215,"./__methods/prepend.js":216,"./__methods/range.js":217,"./__methods/reduce.js":218,"./__methods/repeat-times.js":219,"./__methods/repeat.js":220,"./__methods/reverse.js":221,"./__methods/round-robin.js":222,"./__methods/size.js":223,"./__methods/slice.js":224,"./__methods/some.js":225,"./__methods/split-groups.js":226,"./__methods/split-on-any-seq.js":227,"./__methods/split-on-any.js":228,"./__methods/split-on-seq.js":229,"./__methods/split-on.js":230,"./__methods/split-when.js":231,"./__methods/split.js":232,"./__methods/spliterate-grouped.js":233,"./__methods/spliterate.js":234,"./__methods/starts-with-any-seq.js":235,"./__methods/starts-with-any.js":236,"./__methods/starts-with-seq.js":237,"./__methods/starts-with.js":238,"./__methods/str.js":239,"./__methods/take-last-or.js":240,"./__methods/take-last.js":241,"./__methods/take-sorted.js":242,"./__methods/take-while.js":243,"./__methods/take.js":244,"./__methods/tap.js":245,"./__methods/to-array.js":246,"./__methods/to-object.js":247,"./__methods/window-ahead.js":248,"./__methods/window-behind.js":249,"./__methods/window.js":250,"./__methods/wrap-entries.js":251,"./__methods/wrap-keys.js":252,"./__methods/wrap-values.js":253,"./__methods/zip-all.js":254,"./__methods/zip.js":255,"./methods/append.js":500,"./methods/apply.js":501,"./methods/array-first-or.js":502,"./methods/array-first.js":503,"./methods/array-from-async.js":504,"./methods/array-from.js":505,"./methods/array-last-or.js":506,"./methods/array-last.js":507,"./methods/array-reverse.js":508,"./methods/async-append.js":509,"./methods/async-batch.js":510,"./methods/async-bisect.js":511,"./methods/async-buffer.js":512,"./methods/async-collate.js":513,"./methods/async-compress.js":514,"./methods/async-concat.js":515,"./methods/async-consume.js":516,"./methods/async-cycle-times.js":517,"./methods/async-cycle.js":518,"./methods/async-deep-equal.js":519,"./methods/async-distinct.js":520,"./methods/async-drop-while.js":521,"./methods/async-drop.js":522,"./methods/async-enumerate.js":523,"./methods/async-equal.js":524,"./methods/async-every.js":525,"./methods/async-filter.js":526,"./methods/async-find-best-or.js":527,"./methods/async-find-best.js":528,"./methods/async-find-or.js":529,"./methods/async-find.js":530,"./methods/async-first-or.js":531,"./methods/async-first.js":532,"./methods/async-flat-map.js":533,"./methods/async-flat.js":534,"./methods/async-for-each.js":535,"./methods/async-fork.js":536,"./methods/async-forkerate.js":537,"./methods/async-includes-any-seq.js":538,"./methods/async-includes-any.js":539,"./methods/async-includes-seq.js":540,"./methods/async-includes.js":541,"./methods/async-interleave-ready.js":542,"./methods/async-interleave.js":543,"./methods/async-interpose-seq.js":544,"./methods/async-interpose.js":545,"./methods/async-is-empty.js":546,"./methods/async-is-sorted.js":547,"./methods/async-join-with-seq.js":548,"./methods/async-join-with.js":549,"./methods/async-join.js":550,"./methods/async-map.js":551,"./methods/async-peekerate.js":552,"./methods/async-prepend.js":553,"./methods/async-reduce.js":554,"./methods/async-reverse.js":555,"./methods/async-round-robin.js":556,"./methods/async-size.js":557,"./methods/async-slice.js":558,"./methods/async-some.js":559,"./methods/async-split-groups.js":560,"./methods/async-split-on-any-seq.js":561,"./methods/async-split-on-any.js":562,"./methods/async-split-on-seq.js":563,"./methods/async-split-on.js":564,"./methods/async-split-when.js":565,"./methods/async-split.js":566,"./methods/async-spliterate-grouped.js":567,"./methods/async-spliterate.js":568,"./methods/async-starts-with-any-seq.js":569,"./methods/async-starts-with-any.js":570,"./methods/async-starts-with-seq.js":571,"./methods/async-starts-with.js":572,"./methods/async-str.js":573,"./methods/async-take-last-or.js":574,"./methods/async-take-last.js":575,"./methods/async-take-sorted.js":576,"./methods/async-take-while.js":577,"./methods/async-take.js":578,"./methods/async-tap.js":579,"./methods/async-throttle.js":580,"./methods/async-to-array.js":581,"./methods/async-to-object.js":582,"./methods/async-window-ahead.js":583,"./methods/async-window-behind.js":584,"./methods/async-window.js":585,"./methods/async-wrap.js":586,"./methods/async-zip-all.js":587,"./methods/async-zip.js":588,"./methods/batch.js":589,"./methods/bisect.js":590,"./methods/call.js":591,"./methods/collate.js":592,"./methods/compose.js":593,"./methods/compress.js":594,"./methods/concat.js":595,"./methods/consume.js":596,"./methods/cycle-times.js":597,"./methods/cycle.js":598,"./methods/deep-equal.js":599,"./methods/distinct.js":600,"./methods/drop-while.js":601,"./methods/drop.js":602,"./methods/enumerate.js":603,"./methods/equal.js":604,"./methods/every.js":605,"./methods/exec-pipe.js":606,"./methods/filter.js":607,"./methods/find-best-or.js":608,"./methods/find-best.js":609,"./methods/find-or.js":610,"./methods/find.js":611,"./methods/first-highest.js":612,"./methods/first-lowest.js":613,"./methods/first-or.js":614,"./methods/first.js":615,"./methods/flat-map.js":616,"./methods/flat.js":617,"./methods/for-each.js":618,"./methods/fork.js":619,"./methods/forkerate.js":620,"./methods/get-size.js":621,"./methods/includes-any-seq.js":622,"./methods/includes-any.js":623,"./methods/includes-seq.js":624,"./methods/includes.js":625,"./methods/interleave.js":626,"./methods/interpose-seq.js":627,"./methods/interpose.js":628,"./methods/is-array.js":629,"./methods/is-async-iterable.js":630,"./methods/is-async-loopable.js":631,"./methods/is-async-wrappable.js":632,"./methods/is-empty.js":633,"./methods/is-iterable.js":634,"./methods/is-loopable.js":635,"./methods/is-nil.js":636,"./methods/is-null.js":637,"./methods/is-object.js":638,"./methods/is-sorted.js":639,"./methods/is-string.js":640,"./methods/is-undefined.js":641,"./methods/is-wrappable.js":642,"./methods/join-with-seq.js":643,"./methods/join-with.js":644,"./methods/join.js":645,"./methods/last-highest.js":646,"./methods/last-lowest.js":647,"./methods/map.js":648,"./methods/not-array.js":649,"./methods/not-async-iterable.js":650,"./methods/not-async-loopable.js":651,"./methods/not-async-wrappable.js":652,"./methods/not-iterable.js":653,"./methods/not-loopable.js":654,"./methods/not-nil.js":655,"./methods/not-null.js":656,"./methods/not-object.js":657,"./methods/not-string.js":658,"./methods/not-undefined.js":659,"./methods/not-wrappable.js":660,"./methods/object-entries.js":661,"./methods/object-from-async.js":662,"./methods/object-from.js":663,"./methods/object-keys.js":664,"./methods/object-values.js":665,"./methods/peekerate.js":666,"./methods/pipe.js":667,"./methods/prepend.js":668,"./methods/range.js":669,"./methods/reduce.js":670,"./methods/repeat-times.js":671,"./methods/repeat.js":672,"./methods/reverse.js":673,"./methods/round-robin.js":674,"./methods/size.js":675,"./methods/slice.js":676,"./methods/some.js":677,"./methods/split-groups.js":678,"./methods/split-on-any-seq.js":679,"./methods/split-on-any.js":680,"./methods/split-on-seq.js":681,"./methods/split-on.js":682,"./methods/split-when.js":683,"./methods/split.js":684,"./methods/spliterate-grouped.js":685,"./methods/spliterate.js":686,"./methods/starts-with-any-seq.js":687,"./methods/starts-with-any.js":688,"./methods/starts-with-seq.js":689,"./methods/starts-with.js":690,"./methods/str.js":691,"./methods/string-from-async.js":692,"./methods/string-from.js":693,"./methods/take-last-or.js":694,"./methods/take-last.js":695,"./methods/take-sorted.js":696,"./methods/take-while.js":697,"./methods/take.js":698,"./methods/tap.js":699,"./methods/to-array.js":700,"./methods/to-object.js":701,"./methods/when.js":702,"./methods/window-ahead.js":703,"./methods/window-behind.js":704,"./methods/window.js":705,"./methods/wrap-entries.js":706,"./methods/wrap-keys.js":707,"./methods/wrap-values.js":708,"./methods/wrap.js":709,"./methods/zip-all.js":710,"./methods/zip.js":711}],474:[function(require,module,exports){
var _require = require('./iterable.js'),
    ensureIterable = _require.ensureIterable;

var _require2 = require('../impls/$to-array/to-array.js'),
    __toArray = _require2.__toArray;

var _require3 = require('../impls/$map/map.js'),
    __map = _require3.__map;

function seqsToArray(values) {
  return __toArray(__map(values, function (value) {
    return __toArray(ensureIterable(value));
  }), function (arr) {
    return arr.length > 0;
  });
}

exports.seqsToArray = seqsToArray;
},{"../impls/$map/map.js":338,"../impls/$to-array/to-array.js":399,"./iterable.js":493}],475:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _require = require('./async-iterable.js'),
    asyncEnsureIterable = _require.asyncEnsureIterable;

var _require2 = require('../impls/$to-array/async-to-array.js'),
    __asyncToArray = _require2.__asyncToArray;

var _require3 = require('../impls/$map/async-map.js'),
    __asyncMap = _require3.__asyncMap;

function asyncSeqsToArray(_x) {
  return _asyncSeqsToArray.apply(this, arguments);
}

function _asyncSeqsToArray() {
  _asyncSeqsToArray = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(values) {
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.next = 2;
            return __asyncToArray(__asyncMap(values, function (value) {
              return __asyncToArray(asyncEnsureIterable(value));
            }), function (arr) {
              return arr.length > 0;
            });

          case 2:
            return _context.abrupt("return", _context.sent);

          case 3:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncSeqsToArray.apply(this, arguments);
}

exports.asyncSeqsToArray = asyncSeqsToArray;
},{"../impls/$map/async-map.js":337,"../impls/$to-array/async-to-array.js":398,"./async-iterable.js":480,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/regenerator":65}],476:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

var _createClass = require("@babel/runtime/helpers/createClass");

var _inherits = require("@babel/runtime/helpers/inherits");

var _possibleConstructorReturn = require("@babel/runtime/helpers/possibleConstructorReturn");

var _getPrototypeOf = require("@babel/runtime/helpers/getPrototypeOf");

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _asyncGeneratorDelegate = require("@babel/runtime/helpers/asyncGeneratorDelegate");

var _require = require('./iterable-iterator.js'),
    IterableIterator = _require.IterableIterator;

var _require2 = require('./async-parts-iterator.js'),
    AsyncPartsIterator = _require2.AsyncPartsIterator;

var AsyncBisector = /*#__PURE__*/function (_IterableIterator) {
  _inherits(AsyncBisector, _IterableIterator);

  var _super = _createSuper(AsyncBisector);

  function AsyncBisector(source, strategy, options) {
    var _this;

    _classCallCheck(this, AsyncBisector);

    _this = _super.call(this);
    _this.source = source;
    _this.strategy = strategy;
    _this.options = options;
    _this.partsIterator = null;
    _this.firstPart = null;
    _this.secondPart = null;
    _this.currentIdx = 0;
    return _this;
  }

  _createClass(AsyncBisector, [{
    key: "setupFirst",
    value: function () {
      var _setupFirst = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
        var source, strategy, options, step;
        return _regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                source = this.source, strategy = this.strategy, options = this.options;
                this.partsIterator = this.partsIterator || new AsyncPartsIterator(source, strategy, options);

                if (this.firstPart) {
                  _context.next = 7;
                  break;
                }

                _context.next = 5;
                return this.partsIterator.next();

              case 5:
                step = _context.sent;
                this.firstPart = step.done ? [] : step.value;

              case 7:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function setupFirst() {
        return _setupFirst.apply(this, arguments);
      }

      return setupFirst;
    }()
  }, {
    key: "next",
    value: function next() {
      var self = this;

      switch (this.currentIdx++) {
        case 0:
          return {
            value: _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
              return _regeneratorRuntime.wrap(function _callee2$(_context2) {
                while (1) {
                  switch (_context2.prev = _context2.next) {
                    case 0:
                      _context2.next = 2;
                      return _awaitAsyncGenerator(self.setupFirst());

                    case 2:
                      return _context2.delegateYield(_asyncGeneratorDelegate(_asyncIterator(self.firstPart), _awaitAsyncGenerator), "t0", 3);

                    case 3:
                    case "end":
                      return _context2.stop();
                  }
                }
              }, _callee2);
            }))(),
            done: false
          };

        case 1:
          return {
            value: _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
              var step;
              return _regeneratorRuntime.wrap(function _callee3$(_context3) {
                while (1) {
                  switch (_context3.prev = _context3.next) {
                    case 0:
                      _context3.next = 2;
                      return _awaitAsyncGenerator(self.setupFirst());

                    case 2:
                      _context3.next = 4;
                      return _awaitAsyncGenerator(self.partsIterator.next());

                    case 4:
                      step = _context3.sent;
                      self.secondPart = step.done ? [] : step.value;
                      return _context3.delegateYield(_asyncGeneratorDelegate(_asyncIterator(self.secondPart), _awaitAsyncGenerator), "t0", 7);

                    case 7:
                    case "end":
                      return _context3.stop();
                  }
                }
              }, _callee3);
            }))(),
            done: false
          };

        default:
          return {
            value: undefined,
            done: true
          };
      }
    }
  }, {
    key: "return",
    value: function _return() {
      if (this.currentIdx === 1) {
        throw new Error('You must take both parts of a bisector or neither.');
      }

      return {
        value: undefined,
        done: true
      };
    }
  }]);

  return AsyncBisector;
}(IterableIterator);

exports.AsyncBisector = AsyncBisector;
},{"./async-parts-iterator.js":482,"./iterable-iterator.js":492,"@babel/runtime/helpers/asyncGeneratorDelegate":41,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/createClass":47,"@babel/runtime/helpers/getPrototypeOf":50,"@babel/runtime/helpers/inherits":51,"@babel/runtime/helpers/possibleConstructorReturn":57,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],477:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _createClass = require("@babel/runtime/helpers/createClass");

var _inherits = require("@babel/runtime/helpers/inherits");

var _possibleConstructorReturn = require("@babel/runtime/helpers/possibleConstructorReturn");

var _getPrototypeOf = require("@babel/runtime/helpers/getPrototypeOf");

var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }

var _require = require('./async-iterable-iterator.js'),
    AsyncIterableIterator = _require.AsyncIterableIterator;

var _require2 = require('./async-iterable.js'),
    asyncCallReturn = _require2.asyncCallReturn;

var QueueItem = function QueueItem(step) {
  _classCallCheck(this, QueueItem);

  this.step = step;
  this.next = null;
};

var AsyncFork = /*#__PURE__*/function (_AsyncIterableIterato) {
  _inherits(AsyncFork, _AsyncIterableIterato);

  var _super = _createSuper(AsyncFork);

  function AsyncFork(head, exchange) {
    var _this;

    _classCallCheck(this, AsyncFork);

    _this = _super.call(this);
    _this.head = head;
    _this.done = false;
    _this.exchange = exchange;
    return _this;
  }

  _createClass(AsyncFork, [{
    key: "next",
    value: function () {
      var _next = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
        var done, exchange, head, _head, step;

        return _regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                done = this.done, exchange = this.exchange;

                if (!done) {
                  _context.next = 5;
                  break;
                }

                return _context.abrupt("return", {
                  value: undefined,
                  done: done
                });

              case 5:
                head = this.head;

                if (head.next) {
                  _context.next = 9;
                  break;
                }

                _context.next = 9;
                return exchange.fetch();

              case 9:
                head = head.next;
                _head = head, step = _head.step;
                this.done = step.done;
                this.head = head;
                return _context.abrupt("return", step);

              case 14:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function next() {
        return _next.apply(this, arguments);
      }

      return next;
    }()
  }, {
    key: "return",
    value: function () {
      var _return2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
        var done, exchange;
        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                done = this.done, exchange = this.exchange;

                if (done) {
                  _context2.next = 4;
                  break;
                }

                _context2.next = 4;
                return exchange["return"]();

              case 4:
                return _context2.abrupt("return", {
                  value: undefined,
                  done: true
                });

              case 5:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function _return() {
        return _return2.apply(this, arguments);
      }

      return _return;
    }()
  }]);

  return AsyncFork;
}(AsyncIterableIterator);

var AsyncExchange = /*#__PURE__*/function () {
  function AsyncExchange(iterator) {
    _classCallCheck(this, AsyncExchange);

    this.iterator = iterator;
    this.tail = new QueueItem(null);
    this.head = this.tail;
    this.forks = 0;
  }

  _createClass(AsyncExchange, [{
    key: "fork",
    value: function fork() {
      ++this.forks;
      return new AsyncFork(this.tail, this);
    }
  }, {
    key: "advance",
    value: function advance() {
      this.tail = this.tail.next;
    }
  }, {
    key: "fetch",
    value: function () {
      var _fetch = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
        var step, newItem;
        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                _context3.next = 2;
                return this.iterator.next();

              case 2:
                step = _context3.sent;
                newItem = new QueueItem(step);
                this.head.next = this.head = newItem;

              case 5:
              case "end":
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      function fetch() {
        return _fetch.apply(this, arguments);
      }

      return fetch;
    }()
  }, {
    key: "return",
    value: function () {
      var _return3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                --this.forks;

                if (!(this.forks === 0)) {
                  _context4.next = 4;
                  break;
                }

                _context4.next = 4;
                return asyncCallReturn(this.iterator);

              case 4:
                return _context4.abrupt("return", {
                  value: undefined,
                  done: true
                });

              case 5:
              case "end":
                return _context4.stop();
            }
          }
        }, _callee4, this);
      }));

      function _return() {
        return _return3.apply(this, arguments);
      }

      return _return;
    }()
  }]);

  return AsyncExchange;
}();

exports.AsyncExchange = AsyncExchange;
},{"./async-iterable-iterator.js":479,"./async-iterable.js":480,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/createClass":47,"@babel/runtime/helpers/getPrototypeOf":50,"@babel/runtime/helpers/inherits":51,"@babel/runtime/helpers/possibleConstructorReturn":57,"@babel/runtime/regenerator":65}],478:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

var _createClass = require("@babel/runtime/helpers/createClass");

var _inherits = require("@babel/runtime/helpers/inherits");

var _possibleConstructorReturn = require("@babel/runtime/helpers/possibleConstructorReturn");

var _getPrototypeOf = require("@babel/runtime/helpers/getPrototypeOf");

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }

var _require = require('./async-parts-iterator.js'),
    AsyncPartsIterator = _require.AsyncPartsIterator,
    AsyncPartIterator = _require.AsyncPartIterator;

var _require2 = require('./symbols.js'),
    split = _require2.split;

var AsyncGroupsIterator = /*#__PURE__*/function (_AsyncPartsIterator) {
  _inherits(AsyncGroupsIterator, _AsyncPartsIterator);

  var _super = _createSuper(AsyncGroupsIterator);

  function AsyncGroupsIterator() {
    _classCallCheck(this, AsyncGroupsIterator);

    return _super.apply(this, arguments);
  }

  _createClass(AsyncGroupsIterator, [{
    key: "next",
    value: function () {
      var _next = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
        var spliterator, key;
        return _regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                if (this.initialized) {
                  _context.next = 3;
                  break;
                }

                _context.next = 3;
                return this.init();

              case 3:
                spliterator = this.spliterator;

                if (!(this.currentPart !== null)) {
                  _context.next = 12;
                  break;
                }

                if (!(spliterator.value !== split || spliterator.current === this.splitStep)) {
                  _context.next = 12;
                  break;
                }

                this.currentPart.inactive = true;

              case 7:
                if (!(!spliterator.done && spliterator.value !== split)) {
                  _context.next = 12;
                  break;
                }

                _context.next = 10;
                return spliterator.advance();

              case 10:
                _context.next = 7;
                break;

              case 12:
                if (!spliterator.done) {
                  _context.next = 14;
                  break;
                }

                return _context.abrupt("return", {
                  value: undefined,
                  done: true
                });

              case 14:
                _context.next = 16;
                return spliterator.advance();

              case 16:
                if (!(spliterator.done || spliterator.value === split)) {
                  _context.next = 18;
                  break;
                }

                throw new Error('Unexpected empty group');

              case 18:
                key = spliterator.value;
                _context.next = 21;
                return spliterator.advance();

              case 21:
                this.splitStep = spliterator.current;
                this.currentPart = new AsyncPartIterator(this);
                return _context.abrupt("return", {
                  value: [key, this.currentPart],
                  done: false
                });

              case 24:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function next() {
        return _next.apply(this, arguments);
      }

      return next;
    }()
  }]);

  return AsyncGroupsIterator;
}(AsyncPartsIterator);

exports.AsyncGroupsIterator = AsyncGroupsIterator;
},{"./async-parts-iterator.js":482,"./symbols.js":498,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/createClass":47,"@babel/runtime/helpers/getPrototypeOf":50,"@babel/runtime/helpers/inherits":51,"@babel/runtime/helpers/possibleConstructorReturn":57,"@babel/runtime/regenerator":65}],479:[function(require,module,exports){
var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

var _createClass = require("@babel/runtime/helpers/createClass");

var AsyncIterableIterator = /*#__PURE__*/function () {
  function AsyncIterableIterator() {
    _classCallCheck(this, AsyncIterableIterator);
  }

  _createClass(AsyncIterableIterator, [{
    key: Symbol.asyncIterator,
    value: function value() {
      return this;
    }
  }]);

  return AsyncIterableIterator;
}();

exports.AsyncIterableIterator = AsyncIterableIterator;
},{"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/createClass":47}],480:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _defineProperty = require("@babel/runtime/helpers/defineProperty");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _require = require('../impls/is-async-iterable/is-async-iterable.js'),
    isAsyncIterable = _require.isAsyncIterable;

var _require2 = require('../impls/is-async-loopable/is-async-loopable.js'),
    isAsyncLoopable = _require2.isAsyncLoopable;

var _require3 = require('../impls/is-async-wrappable/is-async-wrappable.js'),
    isAsyncWrappable = _require3.isAsyncWrappable;

var _require4 = require('./async-wrap.js'),
    asyncWrap = _require4.asyncNullableWrap;

var _require5 = require('./iterable.js'),
    BaseIterableIterator = _require5.BaseIterableIterator,
    IterableIterator = _require5.IterableIterator;

var _require6 = require('./curry.js'),
    variadicCurryWithValidation = _require6.variadicCurryWithValidation;

var _require7 = require('./symbols.js'),
    __iterate = _require7.__iterate;

exports.asyncWrap = asyncWrap;
exports.asyncIsIterable = isAsyncIterable;
exports.asyncIsLoopable = isAsyncLoopable;
exports.asyncIsWrappable = isAsyncWrappable;

function asyncCallReturn(_x) {
  return _asyncCallReturn.apply(this, arguments);
}

function _asyncCallReturn() {
  _asyncCallReturn = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterator) {
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            if (!('return' in iterator)) {
              _context.next = 3;
              break;
            }

            _context.next = 3;
            return iterator["return"]();

          case 3:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncCallReturn.apply(this, arguments);
}

exports.asyncCallReturn = asyncCallReturn;

function asyncEnsureIterable(value) {
  if (!isAsyncWrappable(value)) {
    if (typeof value.next === 'function') {
      throw new TypeError('iter-tools received a value that looked like an iterator but was not async iterable. Get help fixing this: https://github.com/iter-tools/iter-tools/wiki/Making-iterators-iterable#async-iterators');
    } else throw new TypeError('Expected an async iterable, sync iterable, null or undefined');
  } else if (isAsyncIterable(value)) {
    return value;
  } else {
    return asyncWrap(value);
  }
}

exports.asyncEnsureIterable = asyncEnsureIterable;

function AsyncIterableIterator() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  BaseIterableIterator.apply(this, args);
}

exports.AsyncIterableIterator = AsyncIterableIterator;
AsyncIterableIterator.prototype = Object.assign(Object.create(BaseIterableIterator.prototype), _defineProperty({
  constructor: AsyncIterableIterator
}, Symbol.asyncIterator, function () {
  return this[__iterate]();
}));

function makeFunctionConfig(fn) {
  var fnConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var _fnConfig$validateArg = fnConfig.validateArgs,
      validateArgs = _fnConfig$validateArg === void 0 ? function (_) {} : _fnConfig$validateArg,
      _fnConfig$variadic = fnConfig.variadic,
      variadic = _fnConfig$variadic === void 0 ? false : _fnConfig$variadic,
      _fnConfig$reduces = fnConfig.reduces,
      reduces = _fnConfig$reduces === void 0 ? false : _fnConfig$reduces,
      _fnConfig$growRight = fnConfig.growRight,
      growRight = _fnConfig$growRight === void 0 ? false : _fnConfig$growRight,
      _fnConfig$minArgs = fnConfig.minArgs,
      minArgs = _fnConfig$minArgs === void 0 ? fn.length - 1 : _fnConfig$minArgs,
      _fnConfig$maxArgs = fnConfig.maxArgs,
      maxArgs = _fnConfig$maxArgs === void 0 ? fn.length - 1 : _fnConfig$maxArgs,
      _fnConfig$forceSync = fnConfig.forceSync,
      forceSync = _fnConfig$forceSync === void 0 ? false : _fnConfig$forceSync,
      _fnConfig$applyOnIter = fnConfig.applyOnIterableArgs,
      applyOnIterableArgs = _fnConfig$applyOnIter === void 0 ? asyncEnsureIterable : _fnConfig$applyOnIter;
  return {
    fn: fn,
    validateArgs: validateArgs,
    variadic: variadic,
    reduces: reduces,
    growRight: growRight,
    minArgs: minArgs,
    maxArgs: maxArgs,
    isIterable: isAsyncWrappable,
    iterableType: 'asyncIterable',
    applyOnIterableArgs: applyOnIterableArgs,
    IterableClass: forceSync ? IterableIterator : AsyncIterableIterator
  };
}

function asyncCache(_x2) {
  return _asyncCache.apply(this, arguments);
}

function _asyncCache() {
  _asyncCache = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(it) {
    var arr, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;

    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            arr = [];
            _iteratorNormalCompletion = true;
            _didIteratorError = false;
            _context2.prev = 3;
            _iterator = _asyncIterator(it);

          case 5:
            _context2.next = 7;
            return _iterator.next();

          case 7:
            _step = _context2.sent;
            _iteratorNormalCompletion = _step.done;
            _context2.next = 11;
            return _step.value;

          case 11:
            _value = _context2.sent;

            if (_iteratorNormalCompletion) {
              _context2.next = 18;
              break;
            }

            value = _value;
            arr.push(value);

          case 15:
            _iteratorNormalCompletion = true;
            _context2.next = 5;
            break;

          case 18:
            _context2.next = 24;
            break;

          case 20:
            _context2.prev = 20;
            _context2.t0 = _context2["catch"](3);
            _didIteratorError = true;
            _iteratorError = _context2.t0;

          case 24:
            _context2.prev = 24;
            _context2.prev = 25;

            if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
              _context2.next = 29;
              break;
            }

            _context2.next = 29;
            return _iterator["return"]();

          case 29:
            _context2.prev = 29;

            if (!_didIteratorError) {
              _context2.next = 32;
              break;
            }

            throw _iteratorError;

          case 32:
            return _context2.finish(29);

          case 33:
            return _context2.finish(24);

          case 34:
            return _context2.abrupt("return", asyncWrapWithIterableIterator(asyncWrap)(arr));

          case 35:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2, null, [[3, 20, 24, 34], [25,, 29, 33]]);
  }));
  return _asyncCache.apply(this, arguments);
}

exports.asyncCache = asyncCache;

function asyncWrapWithIterableIterator(fn) {
  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
      _ref$validateArgs = _ref.validateArgs,
      validateArgs = _ref$validateArgs === void 0 ? function (_) {
    return _;
  } : _ref$validateArgs;

  return function () {
    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      args[_key2] = arguments[_key2];
    }

    validateArgs(args);
    return new AsyncIterableIterator(fn, args);
  };
}

exports.asyncWrapWithIterableIterator = asyncWrapWithIterableIterator;

var asyncIterableCurry = function asyncIterableCurry(fn, config) {
  return variadicCurryWithValidation(makeFunctionConfig(fn, config));
};

exports.asyncIterableCurry = asyncIterableCurry;
},{"../impls/is-async-iterable/is-async-iterable.js":433,"../impls/is-async-loopable/is-async-loopable.js":434,"../impls/is-async-wrappable/is-async-wrappable.js":435,"./async-wrap.js":484,"./curry.js":488,"./iterable.js":493,"./symbols.js":498,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/helpers/defineProperty":48,"@babel/runtime/regenerator":65}],481:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(map);

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function map(iterable, cb) {
  var _iterator, _step, value;

  return _regeneratorRuntime.wrap(function map$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          _iterator = _createForOfIteratorHelper(iterable);
          _context.prev = 1;

          _iterator.s();

        case 3:
          if ((_step = _iterator.n()).done) {
            _context.next = 9;
            break;
          }

          value = _step.value;
          _context.next = 7;
          return cb(value);

        case 7:
          _context.next = 3;
          break;

        case 9:
          _context.next = 14;
          break;

        case 11:
          _context.prev = 11;
          _context.t0 = _context["catch"](1);

          _iterator.e(_context.t0);

        case 14:
          _context.prev = 14;

          _iterator.f();

          return _context.finish(14);

        case 17:
        case "end":
          return _context.stop();
      }
    }
  }, _marked, null, [[1, 11, 14, 17]]);
}

function asyncParallelEach(iterable, cb) {
  return Promise.all(map(iterable, cb));
}

exports.asyncParallelEach = asyncParallelEach;
},{"@babel/runtime/regenerator":65}],482:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

var _createClass = require("@babel/runtime/helpers/createClass");

var _inherits = require("@babel/runtime/helpers/inherits");

var _possibleConstructorReturn = require("@babel/runtime/helpers/possibleConstructorReturn");

var _getPrototypeOf = require("@babel/runtime/helpers/getPrototypeOf");

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }

var _require = require('./symbols.js'),
    split = _require.split;

var _require2 = require('./async-iterable-iterator.js'),
    AsyncIterableIterator = _require2.AsyncIterableIterator;

var _require3 = require('./async-peekerator.js'),
    AsyncPeekerator = _require3.AsyncPeekerator;

var AsyncPartIterator = /*#__PURE__*/function (_AsyncIterableIterato) {
  _inherits(AsyncPartIterator, _AsyncIterableIterato);

  var _super = _createSuper(AsyncPartIterator);

  function AsyncPartIterator(partsIterator) {
    var _this;

    _classCallCheck(this, AsyncPartIterator);

    _this = _super.call(this);
    _this.partsIterator = partsIterator;
    _this.inactive = false;
    _this.done = false;
    return _this;
  }

  _createClass(AsyncPartIterator, [{
    key: "assertActive",
    value: function assertActive() {
      if (this.inactive && !this.done) {
        throw new Error('Cannot take from this split part. It is no longer the active part.');
      }
    }
  }, {
    key: "next",
    value: function () {
      var _next = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
        var spliterator, current;
        return _regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                spliterator = this.partsIterator.spliterator;
                current = spliterator.current;
                this.assertActive();

                if (!(this.done || current.done || current.value === split)) {
                  _context.next = 10;
                  break;
                }

                this.done = true;
                _context.next = 7;
                return this.partsIterator.maybeReturnSource();

              case 7:
                return _context.abrupt("return", {
                  value: undefined,
                  done: true
                });

              case 10:
                _context.next = 12;
                return spliterator.advance();

              case 12:
                return _context.abrupt("return", current);

              case 13:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function next() {
        return _next.apply(this, arguments);
      }

      return next;
    }()
  }, {
    key: "return",
    value: function () {
      var _return2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                this.done = true;
                _context2.next = 3;
                return this.partsIterator.maybeReturnSource();

              case 3:
                return _context2.abrupt("return", {
                  value: undefined,
                  done: true
                });

              case 4:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function _return() {
        return _return2.apply(this, arguments);
      }

      return _return;
    }()
  }, {
    key: "throw",
    value: function () {
      var _throw2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                _context3.next = 2;
                return this["return"]();

              case 2:
                return _context3.abrupt("return", _context3.sent);

              case 3:
              case "end":
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      function _throw() {
        return _throw2.apply(this, arguments);
      }

      return _throw;
    }()
  }]);

  return AsyncPartIterator;
}(AsyncIterableIterator);

exports.AsyncPartIterator = AsyncPartIterator;

var AsyncPartsIterator = /*#__PURE__*/function (_AsyncIterableIterato2) {
  _inherits(AsyncPartsIterator, _AsyncIterableIterato2);

  var _super2 = _createSuper(AsyncPartsIterator);

  function AsyncPartsIterator(source, strategy, options) {
    var _this2;

    _classCallCheck(this, AsyncPartsIterator);

    _this2 = _super2.call(this);
    _this2.source = source;
    _this2.strategy = strategy;
    _this2.options = options;
    _this2.initialized = false;
    _this2.returned = false;
    _this2.spliterator = null;
    _this2.currentPart = null;
    _this2.splitStep = null;
    return _this2;
  }

  _createClass(AsyncPartsIterator, [{
    key: "init",
    value: function () {
      var _init = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
        var source, strategy, options;
        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                this.initialized = true;
                source = this.source, strategy = this.strategy, options = this.options;
                _context4.next = 4;
                return AsyncPeekerator.from(strategy(split, options, source));

              case 4:
                this.spliterator = _context4.sent;

              case 5:
              case "end":
                return _context4.stop();
            }
          }
        }, _callee4, this);
      }));

      function init() {
        return _init.apply(this, arguments);
      }

      return init;
    }()
  }, {
    key: "maybeReturnSource",
    value: function () {
      var _maybeReturnSource = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                if (!(this.spliterator && this.returned && this.currentPart.done)) {
                  _context5.next = 3;
                  break;
                }

                _context5.next = 3;
                return this.spliterator["return"]();

              case 3:
              case "end":
                return _context5.stop();
            }
          }
        }, _callee5, this);
      }));

      function maybeReturnSource() {
        return _maybeReturnSource.apply(this, arguments);
      }

      return maybeReturnSource;
    }()
  }, {
    key: "next",
    value: function () {
      var _next2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
        var spliterator;
        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
          while (1) {
            switch (_context6.prev = _context6.next) {
              case 0:
                if (this.initialized) {
                  _context6.next = 3;
                  break;
                }

                _context6.next = 3;
                return this.init();

              case 3:
                spliterator = this.spliterator;

                if (!spliterator.done) {
                  _context6.next = 6;
                  break;
                }

                return _context6.abrupt("return", {
                  value: undefined,
                  done: true
                });

              case 6:
                if (!(this.currentPart !== null)) {
                  _context6.next = 16;
                  break;
                }

                if (!(spliterator.value !== split || spliterator.current === this.splitStep)) {
                  _context6.next = 14;
                  break;
                }

                this.currentPart.inactive = true;

              case 9:
                if (!(!spliterator.done && spliterator.value !== split)) {
                  _context6.next = 14;
                  break;
                }

                _context6.next = 12;
                return spliterator.advance();

              case 12:
                _context6.next = 9;
                break;

              case 14:
                _context6.next = 16;
                return spliterator.advance();

              case 16:
                this.splitStep = spliterator.current;
                this.currentPart = new AsyncPartIterator(this);
                return _context6.abrupt("return", {
                  value: this.currentPart,
                  done: false
                });

              case 19:
              case "end":
                return _context6.stop();
            }
          }
        }, _callee6, this);
      }));

      function next() {
        return _next2.apply(this, arguments);
      }

      return next;
    }()
  }, {
    key: "return",
    value: function () {
      var _return3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(value) {
        return _regeneratorRuntime.wrap(function _callee7$(_context7) {
          while (1) {
            switch (_context7.prev = _context7.next) {
              case 0:
                this.returned = true;
                _context7.next = 3;
                return this.maybeReturnSource();

              case 3:
                return _context7.abrupt("return", {
                  value: value,
                  done: true
                });

              case 4:
              case "end":
                return _context7.stop();
            }
          }
        }, _callee7, this);
      }));

      function _return(_x) {
        return _return3.apply(this, arguments);
      }

      return _return;
    }()
  }, {
    key: "throw",
    value: function () {
      var _throw3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
        return _regeneratorRuntime.wrap(function _callee8$(_context8) {
          while (1) {
            switch (_context8.prev = _context8.next) {
              case 0:
                _context8.next = 2;
                return this["return"]();

              case 2:
                return _context8.abrupt("return", _context8.sent);

              case 3:
              case "end":
                return _context8.stop();
            }
          }
        }, _callee8, this);
      }));

      function _throw() {
        return _throw3.apply(this, arguments);
      }

      return _throw;
    }()
  }]);

  return AsyncPartsIterator;
}(AsyncIterableIterator);

exports.AsyncPartsIterator = AsyncPartsIterator;
},{"./async-iterable-iterator.js":479,"./async-peekerator.js":483,"./symbols.js":498,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/createClass":47,"@babel/runtime/helpers/getPrototypeOf":50,"@babel/runtime/helpers/inherits":51,"@babel/runtime/helpers/possibleConstructorReturn":57,"@babel/runtime/regenerator":65}],483:[function(require,module,exports){
var _construct = require("@babel/runtime/helpers/construct");

var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _asyncToGenerator = require("@babel/runtime/helpers/asyncToGenerator");

var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

var _createClass = require("@babel/runtime/helpers/createClass");

var _require = require('./async-iterable.js'),
    asyncEnsureIterable = _require.asyncEnsureIterable,
    asyncCallReturn = _require.asyncCallReturn;

var _ = Symbol["for"]('_');

var AsyncPeekeratorIterator = /*#__PURE__*/function () {
  function AsyncPeekeratorIterator(peekr) {
    _classCallCheck(this, AsyncPeekeratorIterator);

    this.peekr = peekr;
  }

  _createClass(AsyncPeekeratorIterator, [{
    key: "next",
    value: function () {
      var _next = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
        var peekr, current;
        return _regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                peekr = this.peekr;
                current = peekr.current;
                _context.next = 4;
                return peekr.advance();

              case 4:
                return _context.abrupt("return", current);

              case 5:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function next() {
        return _next.apply(this, arguments);
      }

      return next;
    }()
  }, {
    key: "return",
    value: function () {
      var _return2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                _context2.next = 2;
                return this.peekr["return"]();

              case 2:
                return _context2.abrupt("return", {
                  value: undefined,
                  done: true
                });

              case 3:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function _return() {
        return _return2.apply(this, arguments);
      }

      return _return;
    }()
  }, {
    key: Symbol.asyncIterator,
    value: function value() {
      return this;
    }
  }]);

  return AsyncPeekeratorIterator;
}();

var AsyncPeekerator = /*#__PURE__*/function () {
  _createClass(AsyncPeekerator, null, [{
    key: "from",
    value: function () {
      var _from = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(iterable) {
        var iterator,
            first,
            _len,
            args,
            _key,
            _args3 = arguments;

        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                iterator = asyncEnsureIterable(iterable)[Symbol.asyncIterator]();
                _context3.next = 3;
                return iterator.next();

              case 3:
                first = _context3.sent;

                for (_len = _args3.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                  args[_key - 1] = _args3[_key];
                }

                return _context3.abrupt("return", _construct(this, [iterator, first].concat(args)));

              case 6:
              case "end":
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      function from(_x) {
        return _from.apply(this, arguments);
      }

      return from;
    }()
  }]);

  function AsyncPeekerator(iterator, first) {
    _classCallCheck(this, AsyncPeekerator);

    this[_] = {
      iterator: iterator,
      current: first,
      index: 0
    };
  }

  _createClass(AsyncPeekerator, [{
    key: "advance",
    value: function () {
      var _advance = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
        var this_;
        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                this_ = this[_];

                if (this_.current.done) {
                  _context4.next = 6;
                  break;
                }

                this_.index++;
                _context4.next = 5;
                return this_.iterator.next();

              case 5:
                this_.current = _context4.sent;

              case 6:
                return _context4.abrupt("return", this);

              case 7:
              case "end":
                return _context4.stop();
            }
          }
        }, _callee4, this);
      }));

      function advance() {
        return _advance.apply(this, arguments);
      }

      return advance;
    }()
  }, {
    key: "return",
    value: function () {
      var _return3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
        var this_;
        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                this_ = this[_];

                if (this.done) {
                  _context5.next = 4;
                  break;
                }

                _context5.next = 4;
                return asyncCallReturn(this_.iterator);

              case 4:
                this_.current = {
                  value: undefined,
                  done: true
                };
                return _context5.abrupt("return", this);

              case 6:
              case "end":
                return _context5.stop();
            }
          }
        }, _callee5, this);
      }));

      function _return() {
        return _return3.apply(this, arguments);
      }

      return _return;
    }()
  }, {
    key: "asIterator",
    value: function asIterator() {
      return new AsyncPeekeratorIterator(this);
    }
  }, {
    key: "current",
    get: function get() {
      return this[_].current;
    }
  }, {
    key: "value",
    get: function get() {
      return this[_].current.value;
    }
  }, {
    key: "done",
    get: function get() {
      return this[_].current.done;
    }
  }, {
    key: "index",
    get: function get() {
      return this[_].index;
    }
  }]);

  return AsyncPeekerator;
}();

exports.AsyncPeekerator = AsyncPeekerator;
},{"./async-iterable.js":480,"@babel/runtime/helpers/asyncToGenerator":43,"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/construct":46,"@babel/runtime/helpers/createClass":47,"@babel/runtime/regenerator":65}],484:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _wrapAsyncGenerator = require("@babel/runtime/helpers/wrapAsyncGenerator");

var _awaitAsyncGenerator = require("@babel/runtime/helpers/awaitAsyncGenerator");

var _asyncIterator = require("@babel/runtime/helpers/asyncIterator");

var _asyncGeneratorDelegate = require("@babel/runtime/helpers/asyncGeneratorDelegate");

function asyncWrap(_x) {
  return _asyncWrap.apply(this, arguments);
}

exports.asyncWrap = asyncWrap;

function _asyncWrap() {
  _asyncWrap = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source) {
    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(source), _awaitAsyncGenerator), "t0", 1);

          case 1:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));
  return _asyncWrap.apply(this, arguments);
}

function asyncNullableWrap(_x2) {
  return _asyncNullableWrap.apply(this, arguments);
}

exports.asyncNullableWrap = asyncNullableWrap;

function _asyncNullableWrap() {
  _asyncNullableWrap = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(source) {
    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            if (!(source != null)) {
              _context2.next = 2;
              break;
            }

            return _context2.delegateYield(_asyncGeneratorDelegate(_asyncIterator(source), _awaitAsyncGenerator), "t0", 2);

          case 2:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2);
  }));
  return _asyncNullableWrap.apply(this, arguments);
}
},{"@babel/runtime/helpers/asyncGeneratorDelegate":41,"@babel/runtime/helpers/asyncIterator":42,"@babel/runtime/helpers/awaitAsyncGenerator":44,"@babel/runtime/helpers/wrapAsyncGenerator":64,"@babel/runtime/regenerator":65}],485:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

var _createClass = require("@babel/runtime/helpers/createClass");

var _inherits = require("@babel/runtime/helpers/inherits");

var _possibleConstructorReturn = require("@babel/runtime/helpers/possibleConstructorReturn");

var _getPrototypeOf = require("@babel/runtime/helpers/getPrototypeOf");

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }

var _require = require('./iterable-iterator.js'),
    IterableIterator = _require.IterableIterator;

var _require2 = require('./parts-iterator.js'),
    PartsIterator = _require2.PartsIterator;

var Bisector = /*#__PURE__*/function (_IterableIterator) {
  _inherits(Bisector, _IterableIterator);

  var _super = _createSuper(Bisector);

  function Bisector(source, strategy, options) {
    var _this;

    _classCallCheck(this, Bisector);

    _this = _super.call(this);
    _this.source = source;
    _this.strategy = strategy;
    _this.options = options;
    _this.partsIterator = null;
    _this.firstPart = null;
    _this.secondPart = null;
    _this.currentIdx = 0;
    return _this;
  }

  _createClass(Bisector, [{
    key: "setupFirst",
    value: function setupFirst() {
      var source = this.source,
          strategy = this.strategy,
          options = this.options;
      this.partsIterator = this.partsIterator || new PartsIterator(source, strategy, options);

      if (!this.firstPart) {
        var step = this.partsIterator.next();
        this.firstPart = step.done ? [] : step.value;
      }
    }
  }, {
    key: "next",
    value: function next() {
      var self = this;

      switch (this.currentIdx++) {
        case 0:
          return {
            value: /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
              return _regeneratorRuntime.wrap(function _callee$(_context) {
                while (1) {
                  switch (_context.prev = _context.next) {
                    case 0:
                      self.setupFirst();
                      return _context.delegateYield(self.firstPart, "t0", 2);

                    case 2:
                    case "end":
                      return _context.stop();
                  }
                }
              }, _callee);
            })(),
            done: false
          };

        case 1:
          return {
            value: /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
              var step;
              return _regeneratorRuntime.wrap(function _callee2$(_context2) {
                while (1) {
                  switch (_context2.prev = _context2.next) {
                    case 0:
                      self.setupFirst();
                      step = self.partsIterator.next();
                      self.secondPart = step.done ? [] : step.value;
                      return _context2.delegateYield(self.secondPart, "t0", 4);

                    case 4:
                    case "end":
                      return _context2.stop();
                  }
                }
              }, _callee2);
            })(),
            done: false
          };

        default:
          return {
            value: undefined,
            done: true
          };
      }
    }
  }, {
    key: "return",
    value: function _return() {
      if (this.currentIdx === 1) {
        throw new Error('You must take both parts of a bisector or neither.');
      }

      return {
        value: undefined,
        done: true
      };
    }
  }]);

  return Bisector;
}(IterableIterator);

exports.Bisector = Bisector;
},{"./iterable-iterator.js":492,"./parts-iterator.js":496,"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/createClass":47,"@babel/runtime/helpers/getPrototypeOf":50,"@babel/runtime/helpers/inherits":51,"@babel/runtime/helpers/possibleConstructorReturn":57,"@babel/runtime/regenerator":65}],486:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

var _createClass = require("@babel/runtime/helpers/createClass");

var _sourceBuffer = Symbol('sourceBuffer');

var ReadOnlyCircularBuffer = /*#__PURE__*/function () {
  function ReadOnlyCircularBuffer(sourceBuffer) {
    _classCallCheck(this, ReadOnlyCircularBuffer);

    this[_sourceBuffer] = sourceBuffer;
  }

  _createClass(ReadOnlyCircularBuffer, [{
    key: "get",
    value: function get(idx) {
      return this[_sourceBuffer].get(idx);
    }
  }, {
    key: "peek",
    value: function peek() {
      return this[_sourceBuffer].peek();
    }
  }, {
    key: "isFull",
    value: function isFull() {
      return this[_sourceBuffer].isFull();
    }
  }, {
    key: Symbol.iterator,
    value: function value() {
      return this[_sourceBuffer][Symbol.iterator]();
    }
  }, {
    key: "size",
    get: function get() {
      return this[_sourceBuffer].size;
    }
  }, {
    key: "capacity",
    get: function get() {
      return this[_sourceBuffer].capacity;
    }
  }]);

  return ReadOnlyCircularBuffer;
}();

exports.ReadOnlyCircularBuffer = ReadOnlyCircularBuffer;

var CircularBuffer = /*#__PURE__*/function () {
  function CircularBuffer(size) {
    _classCallCheck(this, CircularBuffer);

    this._array = new Array(size);
    this._head = size - 1;
    this.size = 0;
  }

  _createClass(CircularBuffer, [{
    key: "push",
    value: function push(value) {
      var array = this._array;
      var head = this._head = (this._head + 1) % array.length;
      var displacedValue = array[head];
      array[head] = value;

      if (this.isFull()) {
        return displacedValue;
      } else {
        this.size++;
        return undefined;
      }
    }
  }, {
    key: "shift",
    value: function shift() {
      if (!this.size) return undefined;
      var value = this.get(0);
      this.size--;
      return value;
    }
  }, {
    key: "peek",
    value: function peek() {
      return this.get(0);
    }
  }, {
    key: "fill",
    value: function fill(filler) {
      this._array.fill(filler);

      this.size = this._array.length;
    }
  }, {
    key: "get",
    value: function get(idx) {
      if (idx >= this.size) return undefined;
      var array = this._array;
      var head = this._head;
      var index = (array.length + head - this.size + 1 + idx) % array.length;
      return array[index];
    }
  }, {
    key: "isFull",
    value: function isFull() {
      return this.size === this._array.length;
    }
  }, {
    key: Symbol.iterator,
    value: /*#__PURE__*/_regeneratorRuntime.mark(function value() {
      var i;
      return _regeneratorRuntime.wrap(function value$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              i = 0;

            case 1:
              if (!(i < this.size)) {
                _context.next = 7;
                break;
              }

              _context.next = 4;
              return this.get(i);

            case 4:
              i++;
              _context.next = 1;
              break;

            case 7:
            case "end":
              return _context.stop();
          }
        }
      }, value, this);
    })
  }, {
    key: "capacity",
    get: function get() {
      return this._array.length;
    }
  }]);

  return CircularBuffer;
}();

exports.CircularBuffer = CircularBuffer;
},{"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/createClass":47,"@babel/runtime/regenerator":65}],487:[function(require,module,exports){
function defaultCompareOrder(a, b) {
  if (a > b) {
    return 1;
  } else if (a < b) {
    return -1;
  } else {
    return 0;
  }
}

exports.defaultCompareOrder = defaultCompareOrder;
},{}],488:[function(require,module,exports){
var _toConsumableArray = require("@babel/runtime/helpers/toConsumableArray");

function curry(fn) {
  var expectedArgsLength = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : fn.length;
  var appliedArgs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
  return function () {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    if (expectedArgsLength <= args.length) {
      return fn.apply(void 0, _toConsumableArray(appliedArgs).concat(args));
    }

    return curry(fn, expectedArgsLength - args.length, [].concat(_toConsumableArray(appliedArgs), args));
  };
}

exports.curry = curry;

function variadicCurryWithValidationInner(config, args) {
  var fn = config.fn,
      validateArgs = config.validateArgs,
      variadic = config.variadic,
      reduces = config.reduces,
      growRight = config.growRight,
      minArgs = config.minArgs,
      maxArgs = config.maxArgs,
      isIterable = config.isIterable,
      iterableType = config.iterableType,
      applyOnIterableArgs = config.applyOnIterableArgs,
      IterableClass = config.IterableClass;

  if (args.length > minArgs) {
    var argsIterable = true;
    var iterableArgsStart = variadic ? args.findIndex(function (arg, i) {
      return isIterable(arg) && i >= minArgs;
    }) : Math.min(maxArgs, args.length - 1);
    var iterableArgsEnd = variadic ? args.length : iterableArgsStart + 1;

    if (variadic) {
      for (var i = iterableArgsStart; i < args.length; i++) {
        argsIterable = argsIterable && isIterable(args[i]);
      }
    } else {
      argsIterable = isIterable(args[iterableArgsStart]);
    }

    if (args.length > maxArgs && (iterableArgsStart === -1 || !argsIterable)) {
      var iterableTypeOrNames = variadic ? "...".concat(iterableType, "s") : iterableType;
      var baseMessage = "".concat(fn.name, " takes up to ").concat(maxArgs, " arguments, followed by ").concat(iterableTypeOrNames, ". ") + "You already passed ".concat(args.length, " arguments");

      if (variadic) {
        throw new Error("".concat(baseMessage, " and the following arguments were not all ").concat(iterableType, "s"));
      } else {
        throw new Error("".concat(baseMessage, " and the last argument was not ").concat(iterableType));
      }
    }

    if (iterableArgsStart >= 0 && argsIterable) {
      for (var _i = iterableArgsStart; _i < iterableArgsEnd; _i++) {
        args[_i] = applyOnIterableArgs(args[_i]);
      }

      var iterablesArg = variadic ? args.slice(iterableArgsStart) : args[iterableArgsStart];
      args.splice(iterableArgsStart);

      if (!growRight) {
        args.reverse();
      }

      args.unshift(iterablesArg);
      validateArgs(args);
      return reduces ? fn.apply(void 0, _toConsumableArray(args)) : new IterableClass(fn, args);
    } else {}
  }

  return variadicCurryWithValidation(config, args);
}

function variadicCurryWithValidation(config) {
  var previousArgs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
  return function () {
    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      args[_key2] = arguments[_key2];
    }

    if (args.length === 0) {
      throw new Error('Cannot make a partial application with no arguments');
    }

    args.unshift.apply(args, _toConsumableArray(previousArgs));
    return variadicCurryWithValidationInner(config, args);
  };
}

exports.variadicCurryWithValidation = variadicCurryWithValidation;
},{"@babel/runtime/helpers/toConsumableArray":61}],489:[function(require,module,exports){
function delay(ms, output) {
  return new Promise(function (resolve, reject) {
    return setTimeout(function () {
      if (output instanceof Error) {
        reject(output);
      } else {
        resolve(output);
      }
    }, ms);
  });
}

exports.delay = delay;
},{}],490:[function(require,module,exports){
var _createClass = require("@babel/runtime/helpers/createClass");

var _inherits = require("@babel/runtime/helpers/inherits");

var _possibleConstructorReturn = require("@babel/runtime/helpers/possibleConstructorReturn");

var _getPrototypeOf = require("@babel/runtime/helpers/getPrototypeOf");

var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }

var _require = require('./iterable-iterator.js'),
    IterableIterator = _require.IterableIterator;

var _require2 = require('./iterable.js'),
    callReturn = _require2.callReturn;

var QueueItem = function QueueItem(step) {
  _classCallCheck(this, QueueItem);

  this.step = step;
  this.next = null;
};

var Fork = /*#__PURE__*/function (_IterableIterator) {
  _inherits(Fork, _IterableIterator);

  var _super = _createSuper(Fork);

  function Fork(head, exchange) {
    var _this;

    _classCallCheck(this, Fork);

    _this = _super.call(this);
    _this.head = head;
    _this.done = false;
    _this.exchange = exchange;
    return _this;
  }

  _createClass(Fork, [{
    key: "next",
    value: function next() {
      var done = this.done,
          exchange = this.exchange;

      if (done) {
        return {
          value: undefined,
          done: done
        };
      } else {
        var head = this.head;
        if (!head.next) exchange.fetch();
        head = head.next;
        var _head = head,
            step = _head.step;
        this.done = step.done;
        this.head = head;
        return step;
      }
    }
  }, {
    key: "return",
    value: function _return() {
      var done = this.done,
          exchange = this.exchange;
      if (!done) exchange["return"]();
      return {
        value: undefined,
        done: true
      };
    }
  }]);

  return Fork;
}(IterableIterator);

var Exchange = /*#__PURE__*/function () {
  function Exchange(iterator) {
    _classCallCheck(this, Exchange);

    this.iterator = iterator;
    this.tail = new QueueItem(null);
    this.head = this.tail;
    this.forks = 0;
  }

  _createClass(Exchange, [{
    key: "fork",
    value: function fork() {
      ++this.forks;
      return new Fork(this.tail, this);
    }
  }, {
    key: "advance",
    value: function advance() {
      this.tail = this.tail.next;
    }
  }, {
    key: "fetch",
    value: function fetch() {
      var step = this.iterator.next();
      var newItem = new QueueItem(step);
      this.head.next = this.head = newItem;
    }
  }, {
    key: "return",
    value: function _return() {
      --this.forks;

      if (this.forks === 0) {
        callReturn(this.iterator);
      }

      return {
        value: undefined,
        done: true
      };
    }
  }]);

  return Exchange;
}();

exports.Exchange = Exchange;
},{"./iterable-iterator.js":492,"./iterable.js":493,"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/createClass":47,"@babel/runtime/helpers/getPrototypeOf":50,"@babel/runtime/helpers/inherits":51,"@babel/runtime/helpers/possibleConstructorReturn":57}],491:[function(require,module,exports){
var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

var _createClass = require("@babel/runtime/helpers/createClass");

var _inherits = require("@babel/runtime/helpers/inherits");

var _possibleConstructorReturn = require("@babel/runtime/helpers/possibleConstructorReturn");

var _getPrototypeOf = require("@babel/runtime/helpers/getPrototypeOf");

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }

var _require = require('./parts-iterator.js'),
    PartsIterator = _require.PartsIterator,
    PartIterator = _require.PartIterator;

var _require2 = require('./symbols.js'),
    split = _require2.split;

var GroupsIterator = /*#__PURE__*/function (_PartsIterator) {
  _inherits(GroupsIterator, _PartsIterator);

  var _super = _createSuper(GroupsIterator);

  function GroupsIterator() {
    _classCallCheck(this, GroupsIterator);

    return _super.apply(this, arguments);
  }

  _createClass(GroupsIterator, [{
    key: "next",
    value: function next() {
      if (!this.initialized) this.init();
      var spliterator = this.spliterator;

      if (this.currentPart !== null) {
        if (spliterator.value !== split || spliterator.current === this.splitStep) {
          this.currentPart.inactive = true;

          while (!spliterator.done && spliterator.value !== split) {
            spliterator.advance();
          }
        }
      }

      if (spliterator.done) {
        return {
          value: undefined,
          done: true
        };
      }

      spliterator.advance();

      if (spliterator.done || spliterator.value === split) {
        throw new Error('Unexpected empty group');
      }

      var key = spliterator.value;
      spliterator.advance();
      this.splitStep = spliterator.current;
      this.currentPart = new PartIterator(this);
      return {
        value: [key, this.currentPart],
        done: false
      };
    }
  }]);

  return GroupsIterator;
}(PartsIterator);

exports.GroupsIterator = GroupsIterator;
},{"./parts-iterator.js":496,"./symbols.js":498,"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/createClass":47,"@babel/runtime/helpers/getPrototypeOf":50,"@babel/runtime/helpers/inherits":51,"@babel/runtime/helpers/possibleConstructorReturn":57}],492:[function(require,module,exports){
var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

var _createClass = require("@babel/runtime/helpers/createClass");

var IterableIterator = /*#__PURE__*/function () {
  function IterableIterator() {
    _classCallCheck(this, IterableIterator);
  }

  _createClass(IterableIterator, [{
    key: Symbol.iterator,
    value: function value() {
      return this;
    }
  }]);

  return IterableIterator;
}();

exports.IterableIterator = IterableIterator;
},{"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/createClass":47}],493:[function(require,module,exports){
var _defineProperty = require("@babel/runtime/helpers/defineProperty");

var _toConsumableArray = require("@babel/runtime/helpers/toConsumableArray");

var _Object$assign;

var _require = require('../impls/is-iterable/is-iterable.js'),
    isIterable = _require.isIterable;

var _require2 = require('../impls/is-loopable/is-loopable.js'),
    isLoopable = _require2.isLoopable;

var _require3 = require('../impls/is-wrappable/is-wrappable.js'),
    isWrappable = _require3.isWrappable;

var _require4 = require('./wrap.js'),
    wrap = _require4.nullableWrap;

var _require5 = require('./curry.js'),
    variadicCurryWithValidation = _require5.variadicCurryWithValidation;

var _require6 = require('./symbols.js'),
    _ = _require6._,
    __iterate = _require6.__iterate;

exports.wrap = wrap;
exports.isIterable = isIterable;
exports.isLoopable = isLoopable;
exports.isWrappable = isWrappable;

function ensureIterable(value) {
  if (!isWrappable(value)) {
    if (typeof value.next === 'function') {
      throw new TypeError('iter-tools received a value that looked like an iterator but was not iterable. Get help fixing this: https://github.com/iter-tools/iter-tools/wiki/Making-iterators-iterable');
    } else throw new TypeError('Expected an iterable, null, or undefined');
  } else if (isIterable(value)) {
    return value;
  } else {
    return wrap(value);
  }
}

exports.ensureIterable = ensureIterable;

function callReturn(iterator) {
  if ('return' in iterator) iterator["return"]();
}

exports.callReturn = callReturn;

function BaseIterableIterator(fn, args) {
  this[_] = {
    fn: fn,
    args: args,
    staticIterator: null
  };
}

exports.BaseIterableIterator = BaseIterableIterator;
Object.assign(BaseIterableIterator.prototype, (_Object$assign = {
  constructor: BaseIterableIterator
}, _defineProperty(_Object$assign, __iterate, function () {
  var _this$_ = this[_],
      fn = _this$_.fn,
      args = _this$_.args;
  return fn.apply(void 0, _toConsumableArray(args));
}), _defineProperty(_Object$assign, "next", function next() {
  var this_ = this[_];
  this_.staticIterator = this_.staticIterator || this[__iterate]();
  return this_.staticIterator.next();
}), _defineProperty(_Object$assign, "return", function _return(value) {
  var this_ = this[_];
  this_.staticIterator = this_.staticIterator || this[__iterate]();
  return this_.staticIterator["return"](value);
}), _defineProperty(_Object$assign, "throw", function _throw(error) {
  var this_ = this[_];
  this_.staticIterator = this_.staticIterator || this[__iterate]();
  return this_.staticIterator["throw"](error);
}), _Object$assign));

function IterableIterator() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  BaseIterableIterator.apply(this, args);
}

exports.IterableIterator = IterableIterator;
IterableIterator.prototype = Object.assign(Object.create(BaseIterableIterator.prototype), _defineProperty({
  constructor: IterableIterator
}, Symbol.iterator, function () {
  return this[__iterate]();
}));

function makeFunctionConfig(fn) {
  var fnConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var _fnConfig$validateArg = fnConfig.validateArgs,
      validateArgs = _fnConfig$validateArg === void 0 ? function (_) {} : _fnConfig$validateArg,
      _fnConfig$variadic = fnConfig.variadic,
      variadic = _fnConfig$variadic === void 0 ? false : _fnConfig$variadic,
      _fnConfig$reduces = fnConfig.reduces,
      reduces = _fnConfig$reduces === void 0 ? false : _fnConfig$reduces,
      _fnConfig$growRight = fnConfig.growRight,
      growRight = _fnConfig$growRight === void 0 ? false : _fnConfig$growRight,
      _fnConfig$minArgs = fnConfig.minArgs,
      minArgs = _fnConfig$minArgs === void 0 ? fn.length - 1 : _fnConfig$minArgs,
      _fnConfig$maxArgs = fnConfig.maxArgs,
      maxArgs = _fnConfig$maxArgs === void 0 ? fn.length - 1 : _fnConfig$maxArgs,
      _fnConfig$applyOnIter = fnConfig.applyOnIterableArgs,
      applyOnIterableArgs = _fnConfig$applyOnIter === void 0 ? ensureIterable : _fnConfig$applyOnIter;
  return {
    fn: fn,
    validateArgs: validateArgs,
    variadic: variadic,
    reduces: reduces,
    growRight: growRight,
    minArgs: minArgs,
    maxArgs: maxArgs,
    isIterable: isWrappable,
    iterableType: 'iterable',
    applyOnIterableArgs: applyOnIterableArgs,
    IterableClass: IterableIterator
  };
}

function cache(it) {
  return _toConsumableArray(it);
}

exports.cache = cache;

function wrapWithIterableIterator(fn) {
  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
      _ref$validateArgs = _ref.validateArgs,
      validateArgs = _ref$validateArgs === void 0 ? function (_) {
    return _;
  } : _ref$validateArgs;

  return function () {
    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      args[_key2] = arguments[_key2];
    }

    validateArgs(args);
    return new IterableIterator(fn, args);
  };
}

exports.wrapWithIterableIterator = wrapWithIterableIterator;

var iterableCurry = function iterableCurry(fn, config) {
  return variadicCurryWithValidation(makeFunctionConfig(fn, config));
};

exports.iterableCurry = iterableCurry;
},{"../impls/is-iterable/is-iterable.js":436,"../impls/is-loopable/is-loopable.js":437,"../impls/is-wrappable/is-wrappable.js":443,"./curry.js":488,"./symbols.js":498,"./wrap.js":499,"@babel/runtime/helpers/defineProperty":48,"@babel/runtime/helpers/toConsumableArray":61}],494:[function(require,module,exports){
function isInteger(value) {
  var nonZero = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  return typeof value === 'number' && !isNaN(value) && isFinite(value) && !(nonZero && value === 0);
}

exports.isInteger = isInteger;

function isPositiveInteger(value) {
  var nonZero = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  return isInteger(value) && (nonZero ? value > 0 : value >= 0);
}

exports.isPositiveInteger = isPositiveInteger;

function isIntegerOrInfinite(value) {
  var nonZero = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  return typeof value === 'number' && !isNaN(value) && !(nonZero && value === 0);
}

exports.isIntegerOrInfinite = isIntegerOrInfinite;
},{}],495:[function(require,module,exports){
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function parallelEach(iterable, cb) {
  var _iterator = _createForOfIteratorHelper(iterable),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var value = _step.value;
      cb(value);
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }
}

exports.parallelEach = parallelEach;
},{}],496:[function(require,module,exports){
var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

var _createClass = require("@babel/runtime/helpers/createClass");

var _inherits = require("@babel/runtime/helpers/inherits");

var _possibleConstructorReturn = require("@babel/runtime/helpers/possibleConstructorReturn");

var _getPrototypeOf = require("@babel/runtime/helpers/getPrototypeOf");

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }

var _require = require('./symbols.js'),
    split = _require.split;

var _require2 = require('./iterable-iterator.js'),
    IterableIterator = _require2.IterableIterator;

var _require3 = require('./peekerator.js'),
    Peekerator = _require3.Peekerator;

var PartIterator = /*#__PURE__*/function (_IterableIterator) {
  _inherits(PartIterator, _IterableIterator);

  var _super = _createSuper(PartIterator);

  function PartIterator(partsIterator) {
    var _this;

    _classCallCheck(this, PartIterator);

    _this = _super.call(this);
    _this.partsIterator = partsIterator;
    _this.inactive = false;
    _this.done = false;
    return _this;
  }

  _createClass(PartIterator, [{
    key: "assertActive",
    value: function assertActive() {
      if (this.inactive && !this.done) {
        throw new Error('Cannot take from this split part. It is no longer the active part.');
      }
    }
  }, {
    key: "next",
    value: function next() {
      var spliterator = this.partsIterator.spliterator;
      var current = spliterator.current;
      this.assertActive();

      if (this.done || current.done || current.value === split) {
        this.done = true;
        this.partsIterator.maybeReturnSource();
        return {
          value: undefined,
          done: true
        };
      } else {
        spliterator.advance();
        return current;
      }
    }
  }, {
    key: "return",
    value: function _return() {
      this.done = true;
      this.partsIterator.maybeReturnSource();
      return {
        value: undefined,
        done: true
      };
    }
  }, {
    key: "throw",
    value: function _throw() {
      return this["return"]();
    }
  }]);

  return PartIterator;
}(IterableIterator);

exports.PartIterator = PartIterator;

var PartsIterator = /*#__PURE__*/function (_IterableIterator2) {
  _inherits(PartsIterator, _IterableIterator2);

  var _super2 = _createSuper(PartsIterator);

  function PartsIterator(source, strategy, options) {
    var _this2;

    _classCallCheck(this, PartsIterator);

    _this2 = _super2.call(this);
    _this2.source = source;
    _this2.strategy = strategy;
    _this2.options = options;
    _this2.initialized = false;
    _this2.returned = false;
    _this2.spliterator = null;
    _this2.currentPart = null;
    _this2.splitStep = null;
    return _this2;
  }

  _createClass(PartsIterator, [{
    key: "init",
    value: function init() {
      this.initialized = true;
      var source = this.source,
          strategy = this.strategy,
          options = this.options;
      this.spliterator = Peekerator.from(strategy(split, options, source));
    }
  }, {
    key: "maybeReturnSource",
    value: function maybeReturnSource() {
      if (this.spliterator && this.returned && this.currentPart.done) {
        this.spliterator["return"]();
      }
    }
  }, {
    key: "next",
    value: function next() {
      if (!this.initialized) this.init();
      var spliterator = this.spliterator;

      if (spliterator.done) {
        return {
          value: undefined,
          done: true
        };
      }

      if (this.currentPart !== null) {
        if (spliterator.value !== split || spliterator.current === this.splitStep) {
          this.currentPart.inactive = true;

          while (!spliterator.done && spliterator.value !== split) {
            spliterator.advance();
          }
        }

        spliterator.advance();
      }

      this.splitStep = spliterator.current;
      this.currentPart = new PartIterator(this);
      return {
        value: this.currentPart,
        done: false
      };
    }
  }, {
    key: "return",
    value: function _return(value) {
      this.returned = true;
      this.maybeReturnSource();
      return {
        value: value,
        done: true
      };
    }
  }, {
    key: "throw",
    value: function _throw() {
      return this["return"]();
    }
  }]);

  return PartsIterator;
}(IterableIterator);

exports.PartsIterator = PartsIterator;
},{"./iterable-iterator.js":492,"./peekerator.js":497,"./symbols.js":498,"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/createClass":47,"@babel/runtime/helpers/getPrototypeOf":50,"@babel/runtime/helpers/inherits":51,"@babel/runtime/helpers/possibleConstructorReturn":57}],497:[function(require,module,exports){
var _construct = require("@babel/runtime/helpers/construct");

var _classCallCheck = require("@babel/runtime/helpers/classCallCheck");

var _createClass = require("@babel/runtime/helpers/createClass");

var _require = require('./iterable.js'),
    ensureIterable = _require.ensureIterable,
    callReturn = _require.callReturn;

var _ = Symbol["for"]('_');

var PeekeratorIterator = /*#__PURE__*/function () {
  function PeekeratorIterator(peekr) {
    _classCallCheck(this, PeekeratorIterator);

    this.peekr = peekr;
  }

  _createClass(PeekeratorIterator, [{
    key: "next",
    value: function next() {
      var peekr = this.peekr;
      var current = peekr.current;
      peekr.advance();
      return current;
    }
  }, {
    key: "return",
    value: function _return() {
      this.peekr["return"]();
      return {
        value: undefined,
        done: true
      };
    }
  }, {
    key: Symbol.iterator,
    value: function value() {
      return this;
    }
  }]);

  return PeekeratorIterator;
}();

var Peekerator = /*#__PURE__*/function () {
  _createClass(Peekerator, null, [{
    key: "from",
    value: function from(iterable) {
      var iterator = ensureIterable(iterable)[Symbol.iterator]();
      var first = iterator.next();

      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }

      return _construct(this, [iterator, first].concat(args));
    }
  }]);

  function Peekerator(iterator, first) {
    _classCallCheck(this, Peekerator);

    this[_] = {
      iterator: iterator,
      current: first,
      index: 0
    };
  }

  _createClass(Peekerator, [{
    key: "advance",
    value: function advance() {
      var this_ = this[_];

      if (!this_.current.done) {
        this_.index++;
        this_.current = this_.iterator.next();
      }

      return this;
    }
  }, {
    key: "return",
    value: function _return() {
      var this_ = this[_];

      if (!this.done) {
        callReturn(this_.iterator);
      }

      this_.current = {
        value: undefined,
        done: true
      };
      return this;
    }
  }, {
    key: "asIterator",
    value: function asIterator() {
      return new PeekeratorIterator(this);
    }
  }, {
    key: "current",
    get: function get() {
      return this[_].current;
    }
  }, {
    key: "value",
    get: function get() {
      return this[_].current.value;
    }
  }, {
    key: "done",
    get: function get() {
      return this[_].current.done;
    }
  }, {
    key: "index",
    get: function get() {
      return this[_].index;
    }
  }]);

  return Peekerator;
}();

exports.Peekerator = Peekerator;
},{"./iterable.js":493,"@babel/runtime/helpers/classCallCheck":45,"@babel/runtime/helpers/construct":46,"@babel/runtime/helpers/createClass":47}],498:[function(require,module,exports){
var _ = Symbol["for"]('_');

exports._ = _;

var __iterate = Symbol('__iterate');

exports.__iterate = __iterate;
var split = Symbol('split');
exports.split = split;
},{}],499:[function(require,module,exports){
var _regeneratorRuntime = require("@babel/runtime/regenerator");

var _marked = /*#__PURE__*/_regeneratorRuntime.mark(wrap),
    _marked2 = /*#__PURE__*/_regeneratorRuntime.mark(nullableWrap);

function wrap(source) {
  return _regeneratorRuntime.wrap(function wrap$(_context) {
    while (1) {
      switch (_context.prev = _context.next) {
        case 0:
          return _context.delegateYield(source, "t0", 1);

        case 1:
        case "end":
          return _context.stop();
      }
    }
  }, _marked);
}

exports.wrap = wrap;

function nullableWrap(source) {
  return _regeneratorRuntime.wrap(function nullableWrap$(_context2) {
    while (1) {
      switch (_context2.prev = _context2.next) {
        case 0:
          if (!(source != null)) {
            _context2.next = 2;
            break;
          }

          return _context2.delegateYield(source, "t0", 2);

        case 2:
        case "end":
          return _context2.stop();
      }
    }
  }, _marked2);
}

exports.nullableWrap = nullableWrap;
},{"@babel/runtime/regenerator":65}],500:[function(require,module,exports){
module.exports = require('../impls/$append/append.js').append;
},{"../impls/$append/append.js":256}],501:[function(require,module,exports){
module.exports = require('../impls/apply/apply.js').apply;
},{"../impls/apply/apply.js":414}],502:[function(require,module,exports){
module.exports = require('../impls/array-first-or/array-first-or.js').arrayFirstOr;
},{"../impls/array-first-or/array-first-or.js":415}],503:[function(require,module,exports){
module.exports = require('../impls/array-first/array-first.js').arrayFirst;
},{"../impls/array-first/array-first.js":416}],504:[function(require,module,exports){
module.exports = require('../impls/array-from-async/array-from-async.js').arrayFromAsync;
},{"../impls/array-from-async/array-from-async.js":417}],505:[function(require,module,exports){
module.exports = require('../impls/array-from/array-from.js').arrayFrom;
},{"../impls/array-from/array-from.js":418}],506:[function(require,module,exports){
module.exports = require('../impls/array-last-or/array-last-or.js').arrayLastOr;
},{"../impls/array-last-or/array-last-or.js":419}],507:[function(require,module,exports){
module.exports = require('../impls/array-last/array-last.js').arrayLast;
},{"../impls/array-last/array-last.js":420}],508:[function(require,module,exports){
module.exports = require('../impls/array-reverse/array-reverse.js').arrayReverse;
},{"../impls/array-reverse/array-reverse.js":421}],509:[function(require,module,exports){
module.exports = require('../impls/$append/async-append.js').asyncAppend;
},{"../impls/$append/async-append.js":257}],510:[function(require,module,exports){
module.exports = require('../impls/$batch/async-batch.js').asyncBatch;
},{"../impls/$batch/async-batch.js":258}],511:[function(require,module,exports){
module.exports = require('../impls/$bisect/async-bisect.js').asyncBisect;
},{"../impls/$bisect/async-bisect.js":260}],512:[function(require,module,exports){
module.exports = require('../impls/async-buffer/async-buffer.js').asyncBuffer;
},{"../impls/async-buffer/async-buffer.js":422}],513:[function(require,module,exports){
module.exports = require('../impls/$collate/async-collate.js').asyncCollate;
},{"../impls/$collate/async-collate.js":262}],514:[function(require,module,exports){
module.exports = require('../impls/$compress/async-compress.js').asyncCompress;
},{"../impls/$compress/async-compress.js":264}],515:[function(require,module,exports){
module.exports = require('../impls/$concat/async-concat.js').asyncConcat;
},{"../impls/$concat/async-concat.js":266}],516:[function(require,module,exports){
module.exports = require('../impls/$consume/async-consume.js').asyncConsume;
},{"../impls/$consume/async-consume.js":268}],517:[function(require,module,exports){
module.exports = require('../impls/$cycle-times/async-cycle-times.js').asyncCycleTimes;
},{"../impls/$cycle-times/async-cycle-times.js":270}],518:[function(require,module,exports){
module.exports = require('../impls/$cycle/async-cycle.js').asyncCycle;
},{"../impls/$cycle/async-cycle.js":272}],519:[function(require,module,exports){
module.exports = require('../impls/$deep-equal/async-deep-equal.js').asyncDeepEqual;
},{"../impls/$deep-equal/async-deep-equal.js":274}],520:[function(require,module,exports){
module.exports = require('../impls/$distinct/async-distinct.js').asyncDistinct;
},{"../impls/$distinct/async-distinct.js":276}],521:[function(require,module,exports){
module.exports = require('../impls/$drop-while/async-drop-while.js').asyncDropWhile;
},{"../impls/$drop-while/async-drop-while.js":278}],522:[function(require,module,exports){
module.exports = require('../impls/$drop/async-drop.js').asyncDrop;
},{"../impls/$drop/async-drop.js":280}],523:[function(require,module,exports){
module.exports = require('../impls/$enumerate/async-enumerate.js').asyncEnumerate;
},{"../impls/$enumerate/async-enumerate.js":282}],524:[function(require,module,exports){
module.exports = require('../impls/$equal/async-equal.js').asyncEqual;
},{"../impls/$equal/async-equal.js":284}],525:[function(require,module,exports){
module.exports = require('../impls/$every/async-every.js').asyncEvery;
},{"../impls/$every/async-every.js":286}],526:[function(require,module,exports){
module.exports = require('../impls/$filter/async-filter.js').asyncFilter;
},{"../impls/$filter/async-filter.js":288}],527:[function(require,module,exports){
module.exports = require('../impls/$find-best-or/async-find-best-or.js').asyncFindBestOr;
},{"../impls/$find-best-or/async-find-best-or.js":290}],528:[function(require,module,exports){
module.exports = require('../impls/$find-best/async-find-best.js').asyncFindBest;
},{"../impls/$find-best/async-find-best.js":292}],529:[function(require,module,exports){
module.exports = require('../impls/$find-or/async-find-or.js').asyncFindOr;
},{"../impls/$find-or/async-find-or.js":294}],530:[function(require,module,exports){
module.exports = require('../impls/$find/async-find.js').asyncFind;
},{"../impls/$find/async-find.js":296}],531:[function(require,module,exports){
module.exports = require('../impls/$first-or/async-first-or.js').asyncFirstOr;
},{"../impls/$first-or/async-first-or.js":298}],532:[function(require,module,exports){
module.exports = require('../impls/$first/async-first.js').asyncFirst;
},{"../impls/$first/async-first.js":300}],533:[function(require,module,exports){
module.exports = require('../impls/$flat-map/async-flat-map.js').asyncFlatMap;
},{"../impls/$flat-map/async-flat-map.js":302}],534:[function(require,module,exports){
module.exports = require('../impls/$flat/async-flat.js').asyncFlat;
},{"../impls/$flat/async-flat.js":304}],535:[function(require,module,exports){
module.exports = require('../impls/$for-each/async-for-each.js').asyncForEach;
},{"../impls/$for-each/async-for-each.js":307}],536:[function(require,module,exports){
module.exports = require('../impls/$fork/async-fork.js').asyncFork;
},{"../impls/$fork/async-fork.js":309}],537:[function(require,module,exports){
module.exports = require('../impls/$forkerate/async-forkerate.js').asyncForkerate;
},{"../impls/$forkerate/async-forkerate.js":311}],538:[function(require,module,exports){
module.exports = require('../impls/$includes-any-seq/async-includes-any-seq.js').asyncIncludesAnySeq;
},{"../impls/$includes-any-seq/async-includes-any-seq.js":313}],539:[function(require,module,exports){
module.exports = require('../impls/$includes-any/async-includes-any.js').asyncIncludesAny;
},{"../impls/$includes-any/async-includes-any.js":315}],540:[function(require,module,exports){
module.exports = require('../impls/$includes-seq/async-includes-seq.js').asyncIncludesSeq;
},{"../impls/$includes-seq/async-includes-seq.js":317}],541:[function(require,module,exports){
module.exports = require('../impls/$includes/async-includes.js').asyncIncludes;
},{"../impls/$includes/async-includes.js":319}],542:[function(require,module,exports){
module.exports = require('../impls/async-interleave-ready/async-interleave-ready.js').asyncInterleaveReady;
},{"../impls/async-interleave-ready/async-interleave-ready.js":423}],543:[function(require,module,exports){
module.exports = require('../impls/$interleave/async-interleave.js').asyncInterleave;
},{"../impls/$interleave/async-interleave.js":321}],544:[function(require,module,exports){
module.exports = require('../impls/$interpose-seq/async-interpose-seq.js').asyncInterposeSeq;
},{"../impls/$interpose-seq/async-interpose-seq.js":323}],545:[function(require,module,exports){
module.exports = require('../impls/$interpose/async-interpose.js').asyncInterpose;
},{"../impls/$interpose/async-interpose.js":325}],546:[function(require,module,exports){
module.exports = require('../impls/$is-empty/async-is-empty.js').asyncIsEmpty;
},{"../impls/$is-empty/async-is-empty.js":327}],547:[function(require,module,exports){
module.exports = require('../impls/$is-sorted/async-is-sorted.js').asyncIsSorted;
},{"../impls/$is-sorted/async-is-sorted.js":329}],548:[function(require,module,exports){
module.exports = require('../impls/$join-with-seq/async-join-with-seq.js').asyncJoinWithSeq;
},{"../impls/$join-with-seq/async-join-with-seq.js":331}],549:[function(require,module,exports){
module.exports = require('../impls/$join-with/async-join-with.js').asyncJoinWith;
},{"../impls/$join-with/async-join-with.js":333}],550:[function(require,module,exports){
module.exports = require('../impls/$join/async-join.js').asyncJoin;
},{"../impls/$join/async-join.js":335}],551:[function(require,module,exports){
module.exports = require('../impls/$map/async-map.js').asyncMap;
},{"../impls/$map/async-map.js":337}],552:[function(require,module,exports){
module.exports = require('../impls/$peekerate/async-peekerate.js').asyncPeekerate;
},{"../impls/$peekerate/async-peekerate.js":339}],553:[function(require,module,exports){
module.exports = require('../impls/$prepend/async-prepend.js').asyncPrepend;
},{"../impls/$prepend/async-prepend.js":341}],554:[function(require,module,exports){
module.exports = require('../impls/$reduce/async-reduce.js').asyncReduce;
},{"../impls/$reduce/async-reduce.js":343}],555:[function(require,module,exports){
module.exports = require('../impls/$reverse/async-reverse.js').asyncReverse;
},{"../impls/$reverse/async-reverse.js":345}],556:[function(require,module,exports){
module.exports = require('../impls/$round-robin/async-round-robin.js').asyncRoundRobin;
},{"../impls/$round-robin/async-round-robin.js":347}],557:[function(require,module,exports){
module.exports = require('../impls/$size/async-size.js').asyncSize;
},{"../impls/$size/async-size.js":350}],558:[function(require,module,exports){
module.exports = require('../impls/$slice/async-slice.js').asyncSlice;
},{"../impls/$slice/async-slice.js":352}],559:[function(require,module,exports){
module.exports = require('../impls/$some/async-some.js').asyncSome;
},{"../impls/$some/async-some.js":355}],560:[function(require,module,exports){
module.exports = require('../impls/$split-groups/async-split-groups.js').asyncSplitGroups;
},{"../impls/$split-groups/async-split-groups.js":357}],561:[function(require,module,exports){
module.exports = require('../impls/$split-on-any-seq/async-split-on-any-seq.js').asyncSplitOnAnySeq;
},{"../impls/$split-on-any-seq/async-split-on-any-seq.js":359}],562:[function(require,module,exports){
module.exports = require('../impls/$split-on-any/async-split-on-any.js').asyncSplitOnAny;
},{"../impls/$split-on-any/async-split-on-any.js":361}],563:[function(require,module,exports){
module.exports = require('../impls/$split-on-seq/async-split-on-seq.js').asyncSplitOnSeq;
},{"../impls/$split-on-seq/async-split-on-seq.js":363}],564:[function(require,module,exports){
module.exports = require('../impls/$split-on/async-split-on.js').asyncSplitOn;
},{"../impls/$split-on/async-split-on.js":365}],565:[function(require,module,exports){
module.exports = require('../impls/$split-when/async-split-when.js').asyncSplitWhen;
},{"../impls/$split-when/async-split-when.js":367}],566:[function(require,module,exports){
module.exports = require('../impls/$split/async-split.js').asyncSplit;
},{"../impls/$split/async-split.js":369}],567:[function(require,module,exports){
module.exports = require('../impls/$spliterate-grouped/async-spliterate-grouped.js').asyncSpliterateGrouped;
},{"../impls/$spliterate-grouped/async-spliterate-grouped.js":371}],568:[function(require,module,exports){
module.exports = require('../impls/$spliterate/async-spliterate.js').asyncSpliterate;
},{"../impls/$spliterate/async-spliterate.js":373}],569:[function(require,module,exports){
module.exports = require('../impls/$starts-with-any-seq/async-starts-with-any-seq.js').asyncStartsWithAnySeq;
},{"../impls/$starts-with-any-seq/async-starts-with-any-seq.js":375}],570:[function(require,module,exports){
module.exports = require('../impls/$starts-with-any/async-starts-with-any.js').asyncStartsWithAny;
},{"../impls/$starts-with-any/async-starts-with-any.js":377}],571:[function(require,module,exports){
module.exports = require('../impls/$starts-with-seq/async-starts-with-seq.js').asyncStartsWithSeq;
},{"../impls/$starts-with-seq/async-starts-with-seq.js":379}],572:[function(require,module,exports){
module.exports = require('../impls/$starts-with/async-starts-with.js').asyncStartsWith;
},{"../impls/$starts-with/async-starts-with.js":381}],573:[function(require,module,exports){
module.exports = require('../impls/$str/async-str.js').asyncStr;
},{"../impls/$str/async-str.js":383}],574:[function(require,module,exports){
module.exports = require('../impls/$take-last-or/async-take-last-or.js').asyncTakeLastOr;
},{"../impls/$take-last-or/async-take-last-or.js":385}],575:[function(require,module,exports){
module.exports = require('../impls/$take-last/async-take-last.js').asyncTakeLast;
},{"../impls/$take-last/async-take-last.js":387}],576:[function(require,module,exports){
module.exports = require('../impls/$take-sorted/async-take-sorted.js').asyncTakeSorted;
},{"../impls/$take-sorted/async-take-sorted.js":389}],577:[function(require,module,exports){
module.exports = require('../impls/$take-while/async-take-while.js').asyncTakeWhile;
},{"../impls/$take-while/async-take-while.js":392}],578:[function(require,module,exports){
module.exports = require('../impls/$take/async-take.js').asyncTake;
},{"../impls/$take/async-take.js":394}],579:[function(require,module,exports){
module.exports = require('../impls/$tap/async-tap.js').asyncTap;
},{"../impls/$tap/async-tap.js":396}],580:[function(require,module,exports){
module.exports = require('../impls/async-throttle/async-throttle.js').asyncThrottle;
},{"../impls/async-throttle/async-throttle.js":425}],581:[function(require,module,exports){
module.exports = require('../impls/$to-array/async-to-array.js').asyncToArray;
},{"../impls/$to-array/async-to-array.js":398}],582:[function(require,module,exports){
module.exports = require('../impls/$to-object/async-to-object.js').asyncToObject;
},{"../impls/$to-object/async-to-object.js":400}],583:[function(require,module,exports){
module.exports = require('../impls/$window-ahead/async-window-ahead.js').asyncWindowAhead;
},{"../impls/$window-ahead/async-window-ahead.js":402}],584:[function(require,module,exports){
module.exports = require('../impls/$window-behind/async-window-behind.js').asyncWindowBehind;
},{"../impls/$window-behind/async-window-behind.js":404}],585:[function(require,module,exports){
module.exports = require('../impls/$window/async-window.js').asyncWindow;
},{"../impls/$window/async-window.js":406}],586:[function(require,module,exports){
module.exports = require('../impls/$wrap/async-wrap.js').asyncWrap;
},{"../impls/$wrap/async-wrap.js":408}],587:[function(require,module,exports){
module.exports = require('../impls/$zip-all/async-zip-all.js').asyncZipAll;
},{"../impls/$zip-all/async-zip-all.js":410}],588:[function(require,module,exports){
module.exports = require('../impls/$zip/async-zip.js').asyncZip;
},{"../impls/$zip/async-zip.js":412}],589:[function(require,module,exports){
module.exports = require('../impls/$batch/batch.js').batch;
},{"../impls/$batch/batch.js":259}],590:[function(require,module,exports){
module.exports = require('../impls/$bisect/bisect.js').bisect;
},{"../impls/$bisect/bisect.js":261}],591:[function(require,module,exports){
module.exports = require('../impls/call/call.js').call;
},{"../impls/call/call.js":426}],592:[function(require,module,exports){
module.exports = require('../impls/$collate/collate.js').collate;
},{"../impls/$collate/collate.js":263}],593:[function(require,module,exports){
module.exports = require('../impls/compose/compose.js').compose;
},{"../impls/compose/compose.js":427}],594:[function(require,module,exports){
module.exports = require('../impls/$compress/compress.js').compress;
},{"../impls/$compress/compress.js":265}],595:[function(require,module,exports){
module.exports = require('../impls/$concat/concat.js').concat;
},{"../impls/$concat/concat.js":267}],596:[function(require,module,exports){
module.exports = require('../impls/$consume/consume.js').consume;
},{"../impls/$consume/consume.js":269}],597:[function(require,module,exports){
module.exports = require('../impls/$cycle-times/cycle-times.js').cycleTimes;
},{"../impls/$cycle-times/cycle-times.js":271}],598:[function(require,module,exports){
module.exports = require('../impls/$cycle/cycle.js').cycle;
},{"../impls/$cycle/cycle.js":273}],599:[function(require,module,exports){
module.exports = require('../impls/$deep-equal/deep-equal.js').deepEqual;
},{"../impls/$deep-equal/deep-equal.js":275}],600:[function(require,module,exports){
module.exports = require('../impls/$distinct/distinct.js').distinct;
},{"../impls/$distinct/distinct.js":277}],601:[function(require,module,exports){
module.exports = require('../impls/$drop-while/drop-while.js').dropWhile;
},{"../impls/$drop-while/drop-while.js":279}],602:[function(require,module,exports){
module.exports = require('../impls/$drop/drop.js').drop;
},{"../impls/$drop/drop.js":281}],603:[function(require,module,exports){
module.exports = require('../impls/$enumerate/enumerate.js').enumerate;
},{"../impls/$enumerate/enumerate.js":283}],604:[function(require,module,exports){
module.exports = require('../impls/$equal/equal.js').equal;
},{"../impls/$equal/equal.js":285}],605:[function(require,module,exports){
module.exports = require('../impls/$every/every.js').every;
},{"../impls/$every/every.js":287}],606:[function(require,module,exports){
module.exports = require('../impls/exec-pipe/exec-pipe.js').execPipe;
},{"../impls/exec-pipe/exec-pipe.js":428}],607:[function(require,module,exports){
module.exports = require('../impls/$filter/filter.js').filter;
},{"../impls/$filter/filter.js":289}],608:[function(require,module,exports){
module.exports = require('../impls/$find-best-or/find-best-or.js').findBestOr;
},{"../impls/$find-best-or/find-best-or.js":291}],609:[function(require,module,exports){
module.exports = require('../impls/$find-best/find-best.js').findBest;
},{"../impls/$find-best/find-best.js":293}],610:[function(require,module,exports){
module.exports = require('../impls/$find-or/find-or.js').findOr;
},{"../impls/$find-or/find-or.js":295}],611:[function(require,module,exports){
module.exports = require('../impls/$find/find.js').find;
},{"../impls/$find/find.js":297}],612:[function(require,module,exports){
module.exports = require('../impls/first-highest/first-highest.js').firstHighest;
},{"../impls/first-highest/first-highest.js":429}],613:[function(require,module,exports){
module.exports = require('../impls/first-lowest/first-lowest.js').firstLowest;
},{"../impls/first-lowest/first-lowest.js":430}],614:[function(require,module,exports){
module.exports = require('../impls/$first-or/first-or.js').firstOr;
},{"../impls/$first-or/first-or.js":299}],615:[function(require,module,exports){
module.exports = require('../impls/$first/first.js').first;
},{"../impls/$first/first.js":301}],616:[function(require,module,exports){
module.exports = require('../impls/$flat-map/flat-map.js').flatMap;
},{"../impls/$flat-map/flat-map.js":303}],617:[function(require,module,exports){
module.exports = require('../impls/$flat/flat.js').flat;
},{"../impls/$flat/flat.js":305}],618:[function(require,module,exports){
module.exports = require('../impls/$for-each/for-each.js').forEach;
},{"../impls/$for-each/for-each.js":308}],619:[function(require,module,exports){
module.exports = require('../impls/$fork/fork.js').fork;
},{"../impls/$fork/fork.js":310}],620:[function(require,module,exports){
module.exports = require('../impls/$forkerate/forkerate.js').forkerate;
},{"../impls/$forkerate/forkerate.js":312}],621:[function(require,module,exports){
module.exports = require('../impls/get-size/get-size.js').getSize;
},{"../impls/get-size/get-size.js":431}],622:[function(require,module,exports){
module.exports = require('../impls/$includes-any-seq/includes-any-seq.js').includesAnySeq;
},{"../impls/$includes-any-seq/includes-any-seq.js":314}],623:[function(require,module,exports){
module.exports = require('../impls/$includes-any/includes-any.js').includesAny;
},{"../impls/$includes-any/includes-any.js":316}],624:[function(require,module,exports){
module.exports = require('../impls/$includes-seq/includes-seq.js').includesSeq;
},{"../impls/$includes-seq/includes-seq.js":318}],625:[function(require,module,exports){
module.exports = require('../impls/$includes/includes.js').includes;
},{"../impls/$includes/includes.js":320}],626:[function(require,module,exports){
module.exports = require('../impls/$interleave/interleave.js').interleave;
},{"../impls/$interleave/interleave.js":322}],627:[function(require,module,exports){
module.exports = require('../impls/$interpose-seq/interpose-seq.js').interposeSeq;
},{"../impls/$interpose-seq/interpose-seq.js":324}],628:[function(require,module,exports){
module.exports = require('../impls/$interpose/interpose.js').interpose;
},{"../impls/$interpose/interpose.js":326}],629:[function(require,module,exports){
module.exports = require('../impls/is-array/is-array.js').isArray;
},{"../impls/is-array/is-array.js":432}],630:[function(require,module,exports){
module.exports = require('../impls/is-async-iterable/is-async-iterable.js').isAsyncIterable;
},{"../impls/is-async-iterable/is-async-iterable.js":433}],631:[function(require,module,exports){
module.exports = require('../impls/is-async-loopable/is-async-loopable.js').isAsyncLoopable;
},{"../impls/is-async-loopable/is-async-loopable.js":434}],632:[function(require,module,exports){
module.exports = require('../impls/is-async-wrappable/is-async-wrappable.js').isAsyncWrappable;
},{"../impls/is-async-wrappable/is-async-wrappable.js":435}],633:[function(require,module,exports){
module.exports = require('../impls/$is-empty/is-empty.js').isEmpty;
},{"../impls/$is-empty/is-empty.js":328}],634:[function(require,module,exports){
module.exports = require('../impls/is-iterable/is-iterable.js').isIterable;
},{"../impls/is-iterable/is-iterable.js":436}],635:[function(require,module,exports){
module.exports = require('../impls/is-loopable/is-loopable.js').isLoopable;
},{"../impls/is-loopable/is-loopable.js":437}],636:[function(require,module,exports){
module.exports = require('../impls/is-nil/is-nil.js').isNil;
},{"../impls/is-nil/is-nil.js":438}],637:[function(require,module,exports){
module.exports = require('../impls/is-null/is-null.js').isNull;
},{"../impls/is-null/is-null.js":439}],638:[function(require,module,exports){
module.exports = require('../impls/is-object/is-object.js').isObject;
},{"../impls/is-object/is-object.js":440}],639:[function(require,module,exports){
module.exports = require('../impls/$is-sorted/is-sorted.js').isSorted;
},{"../impls/$is-sorted/is-sorted.js":330}],640:[function(require,module,exports){
module.exports = require('../impls/is-string/is-string.js').isString;
},{"../impls/is-string/is-string.js":441}],641:[function(require,module,exports){
module.exports = require('../impls/is-undefined/is-undefined.js').isUndefined;
},{"../impls/is-undefined/is-undefined.js":442}],642:[function(require,module,exports){
module.exports = require('../impls/is-wrappable/is-wrappable.js').isWrappable;
},{"../impls/is-wrappable/is-wrappable.js":443}],643:[function(require,module,exports){
module.exports = require('../impls/$join-with-seq/join-with-seq.js').joinWithSeq;
},{"../impls/$join-with-seq/join-with-seq.js":332}],644:[function(require,module,exports){
module.exports = require('../impls/$join-with/join-with.js').joinWith;
},{"../impls/$join-with/join-with.js":334}],645:[function(require,module,exports){
module.exports = require('../impls/$join/join.js').join;
},{"../impls/$join/join.js":336}],646:[function(require,module,exports){
module.exports = require('../impls/last-highest/last-highest.js').lastHighest;
},{"../impls/last-highest/last-highest.js":444}],647:[function(require,module,exports){
module.exports = require('../impls/last-lowest/last-lowest.js').lastLowest;
},{"../impls/last-lowest/last-lowest.js":445}],648:[function(require,module,exports){
module.exports = require('../impls/$map/map.js').map;
},{"../impls/$map/map.js":338}],649:[function(require,module,exports){
module.exports = require('../impls/not-array/not-array.js').notArray;
},{"../impls/not-array/not-array.js":446}],650:[function(require,module,exports){
module.exports = require('../impls/not-async-iterable/not-async-iterable.js').notAsyncIterable;
},{"../impls/not-async-iterable/not-async-iterable.js":447}],651:[function(require,module,exports){
module.exports = require('../impls/not-async-loopable/not-async-loopable.js').notAsyncLoopable;
},{"../impls/not-async-loopable/not-async-loopable.js":448}],652:[function(require,module,exports){
module.exports = require('../impls/not-async-wrappable/not-async-wrappable.js').notAsyncWrappable;
},{"../impls/not-async-wrappable/not-async-wrappable.js":449}],653:[function(require,module,exports){
module.exports = require('../impls/not-iterable/not-iterable.js').notIterable;
},{"../impls/not-iterable/not-iterable.js":450}],654:[function(require,module,exports){
module.exports = require('../impls/not-loopable/not-loopable.js').notLoopable;
},{"../impls/not-loopable/not-loopable.js":451}],655:[function(require,module,exports){
module.exports = require('../impls/not-nil/not-nil.js').notNil;
},{"../impls/not-nil/not-nil.js":452}],656:[function(require,module,exports){
module.exports = require('../impls/not-null/not-null.js').notNull;
},{"../impls/not-null/not-null.js":453}],657:[function(require,module,exports){
module.exports = require('../impls/not-object/not-object.js').notObject;
},{"../impls/not-object/not-object.js":454}],658:[function(require,module,exports){
module.exports = require('../impls/not-string/not-string.js').notString;
},{"../impls/not-string/not-string.js":455}],659:[function(require,module,exports){
module.exports = require('../impls/not-undefined/not-undefined.js').notUndefined;
},{"../impls/not-undefined/not-undefined.js":456}],660:[function(require,module,exports){
module.exports = require('../impls/not-wrappable/not-wrappable.js').notWrappable;
},{"../impls/not-wrappable/not-wrappable.js":457}],661:[function(require,module,exports){
module.exports = require('../impls/object-entries/object-entries.js').objectEntries;
},{"../impls/object-entries/object-entries.js":458}],662:[function(require,module,exports){
module.exports = require('../impls/object-from-async/object-from-async.js').objectFromAsync;
},{"../impls/object-from-async/object-from-async.js":459}],663:[function(require,module,exports){
module.exports = require('../impls/object-from/object-from.js').objectFrom;
},{"../impls/object-from/object-from.js":460}],664:[function(require,module,exports){
module.exports = require('../impls/object-keys/object-keys.js').objectKeys;
},{"../impls/object-keys/object-keys.js":461}],665:[function(require,module,exports){
module.exports = require('../impls/object-values/object-values.js').objectValues;
},{"../impls/object-values/object-values.js":462}],666:[function(require,module,exports){
module.exports = require('../impls/$peekerate/peekerate.js').peekerate;
},{"../impls/$peekerate/peekerate.js":340}],667:[function(require,module,exports){
module.exports = require('../impls/pipe/pipe.js').pipe;
},{"../impls/pipe/pipe.js":463}],668:[function(require,module,exports){
module.exports = require('../impls/$prepend/prepend.js').prepend;
},{"../impls/$prepend/prepend.js":342}],669:[function(require,module,exports){
module.exports = require('../impls/range/range.js').range;
},{"../impls/range/range.js":464}],670:[function(require,module,exports){
module.exports = require('../impls/$reduce/reduce.js').reduce;
},{"../impls/$reduce/reduce.js":344}],671:[function(require,module,exports){
module.exports = require('../impls/repeat-times/repeat-times.js').repeatTimes;
},{"../impls/repeat-times/repeat-times.js":465}],672:[function(require,module,exports){
module.exports = require('../impls/repeat/repeat.js').repeat;
},{"../impls/repeat/repeat.js":466}],673:[function(require,module,exports){
module.exports = require('../impls/$reverse/reverse.js').reverse;
},{"../impls/$reverse/reverse.js":346}],674:[function(require,module,exports){
module.exports = require('../impls/$round-robin/round-robin.js').roundRobin;
},{"../impls/$round-robin/round-robin.js":349}],675:[function(require,module,exports){
module.exports = require('../impls/$size/size.js').size;
},{"../impls/$size/size.js":351}],676:[function(require,module,exports){
module.exports = require('../impls/$slice/slice.js').slice;
},{"../impls/$slice/slice.js":354}],677:[function(require,module,exports){
module.exports = require('../impls/$some/some.js').some;
},{"../impls/$some/some.js":356}],678:[function(require,module,exports){
module.exports = require('../impls/$split-groups/split-groups.js').splitGroups;
},{"../impls/$split-groups/split-groups.js":358}],679:[function(require,module,exports){
module.exports = require('../impls/$split-on-any-seq/split-on-any-seq.js').splitOnAnySeq;
},{"../impls/$split-on-any-seq/split-on-any-seq.js":360}],680:[function(require,module,exports){
module.exports = require('../impls/$split-on-any/split-on-any.js').splitOnAny;
},{"../impls/$split-on-any/split-on-any.js":362}],681:[function(require,module,exports){
module.exports = require('../impls/$split-on-seq/split-on-seq.js').splitOnSeq;
},{"../impls/$split-on-seq/split-on-seq.js":364}],682:[function(require,module,exports){
module.exports = require('../impls/$split-on/split-on.js').splitOn;
},{"../impls/$split-on/split-on.js":366}],683:[function(require,module,exports){
module.exports = require('../impls/$split-when/split-when.js').splitWhen;
},{"../impls/$split-when/split-when.js":368}],684:[function(require,module,exports){
module.exports = require('../impls/$split/split.js').split;
},{"../impls/$split/split.js":370}],685:[function(require,module,exports){
module.exports = require('../impls/$spliterate-grouped/spliterate-grouped.js').spliterateGrouped;
},{"../impls/$spliterate-grouped/spliterate-grouped.js":372}],686:[function(require,module,exports){
module.exports = require('../impls/$spliterate/spliterate.js').spliterate;
},{"../impls/$spliterate/spliterate.js":374}],687:[function(require,module,exports){
module.exports = require('../impls/$starts-with-any-seq/starts-with-any-seq.js').startsWithAnySeq;
},{"../impls/$starts-with-any-seq/starts-with-any-seq.js":376}],688:[function(require,module,exports){
module.exports = require('../impls/$starts-with-any/starts-with-any.js').startsWithAny;
},{"../impls/$starts-with-any/starts-with-any.js":378}],689:[function(require,module,exports){
module.exports = require('../impls/$starts-with-seq/starts-with-seq.js').startsWithSeq;
},{"../impls/$starts-with-seq/starts-with-seq.js":380}],690:[function(require,module,exports){
module.exports = require('../impls/$starts-with/starts-with.js').startsWith;
},{"../impls/$starts-with/starts-with.js":382}],691:[function(require,module,exports){
module.exports = require('../impls/$str/str.js').str;
},{"../impls/$str/str.js":384}],692:[function(require,module,exports){
module.exports = require('../impls/string-from-async/string-from-async.js').stringFromAsync;
},{"../impls/string-from-async/string-from-async.js":467}],693:[function(require,module,exports){
module.exports = require('../impls/string-from/string-from.js').stringFrom;
},{"../impls/string-from/string-from.js":468}],694:[function(require,module,exports){
module.exports = require('../impls/$take-last-or/take-last-or.js').takeLastOr;
},{"../impls/$take-last-or/take-last-or.js":386}],695:[function(require,module,exports){
module.exports = require('../impls/$take-last/take-last.js').takeLast;
},{"../impls/$take-last/take-last.js":388}],696:[function(require,module,exports){
module.exports = require('../impls/$take-sorted/take-sorted.js').takeSorted;
},{"../impls/$take-sorted/take-sorted.js":391}],697:[function(require,module,exports){
module.exports = require('../impls/$take-while/take-while.js').takeWhile;
},{"../impls/$take-while/take-while.js":393}],698:[function(require,module,exports){
module.exports = require('../impls/$take/take.js').take;
},{"../impls/$take/take.js":395}],699:[function(require,module,exports){
module.exports = require('../impls/$tap/tap.js').tap;
},{"../impls/$tap/tap.js":397}],700:[function(require,module,exports){
module.exports = require('../impls/$to-array/to-array.js').toArray;
},{"../impls/$to-array/to-array.js":399}],701:[function(require,module,exports){
module.exports = require('../impls/$to-object/to-object.js').toObject;
},{"../impls/$to-object/to-object.js":401}],702:[function(require,module,exports){
module.exports = require('../impls/when/when.js').when;
},{"../impls/when/when.js":469}],703:[function(require,module,exports){
module.exports = require('../impls/$window-ahead/window-ahead.js').windowAhead;
},{"../impls/$window-ahead/window-ahead.js":403}],704:[function(require,module,exports){
module.exports = require('../impls/$window-behind/window-behind.js').windowBehind;
},{"../impls/$window-behind/window-behind.js":405}],705:[function(require,module,exports){
module.exports = require('../impls/$window/window.js').window;
},{"../impls/$window/window.js":407}],706:[function(require,module,exports){
module.exports = require('../impls/wrap-entries/wrap-entries.js').wrapEntries;
},{"../impls/wrap-entries/wrap-entries.js":470}],707:[function(require,module,exports){
module.exports = require('../impls/wrap-keys/wrap-keys.js').wrapKeys;
},{"../impls/wrap-keys/wrap-keys.js":471}],708:[function(require,module,exports){
module.exports = require('../impls/wrap-values/wrap-values.js').wrapValues;
},{"../impls/wrap-values/wrap-values.js":472}],709:[function(require,module,exports){
module.exports = require('../impls/$wrap/wrap.js').wrap;
},{"../impls/$wrap/wrap.js":409}],710:[function(require,module,exports){
module.exports = require('../impls/$zip-all/zip-all.js').zipAll;
},{"../impls/$zip-all/zip-all.js":411}],711:[function(require,module,exports){
module.exports = require('../impls/$zip/zip.js').zip;
},{"../impls/$zip/zip.js":413}],712:[function(require,module,exports){
/*
 Copyright 2013 Daniel Wirtz <dcode@dcode.io>
 Copyright 2009 The Closure Library Authors. All Rights Reserved.

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS-IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */

/**
 * @license long.js (c) 2013 Daniel Wirtz <dcode@dcode.io>
 * Released under the Apache License, Version 2.0
 * see: https://github.com/dcodeIO/long.js for details
 */
(function(global, factory) {

    /* AMD */ if (typeof define === 'function' && define["amd"])
        define([], factory);
    /* CommonJS */ else if (typeof require === 'function' && typeof module === "object" && module && module["exports"])
        module["exports"] = factory();
    /* Global */ else
        (global["dcodeIO"] = global["dcodeIO"] || {})["Long"] = factory();

})(this, function() {
    "use strict";

    /**
     * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.
     *  See the from* functions below for more convenient ways of constructing Longs.
     * @exports Long
     * @class A Long class for representing a 64 bit two's-complement integer value.
     * @param {number} low The low (signed) 32 bits of the long
     * @param {number} high The high (signed) 32 bits of the long
     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
     * @constructor
     */
    function Long(low, high, unsigned) {

        /**
         * The low 32 bits as a signed value.
         * @type {number}
         */
        this.low = low | 0;

        /**
         * The high 32 bits as a signed value.
         * @type {number}
         */
        this.high = high | 0;

        /**
         * Whether unsigned or not.
         * @type {boolean}
         */
        this.unsigned = !!unsigned;
    }

    // The internal representation of a long is the two given signed, 32-bit values.
    // We use 32-bit pieces because these are the size of integers on which
    // Javascript performs bit-operations.  For operations like addition and
    // multiplication, we split each number into 16 bit pieces, which can easily be
    // multiplied within Javascript's floating-point representation without overflow
    // or change in sign.
    //
    // In the algorithms below, we frequently reduce the negative case to the
    // positive case by negating the input(s) and then post-processing the result.
    // Note that we must ALWAYS check specially whether those values are MIN_VALUE
    // (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as
    // a positive number, it overflows back into a negative).  Not handling this
    // case would often result in infinite recursion.
    //
    // Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*
    // methods on which they depend.

    /**
     * An indicator used to reliably determine if an object is a Long or not.
     * @type {boolean}
     * @const
     * @private
     */
    Long.prototype.__isLong__;

    Object.defineProperty(Long.prototype, "__isLong__", {
        value: true,
        enumerable: false,
        configurable: false
    });

    /**
     * @function
     * @param {*} obj Object
     * @returns {boolean}
     * @inner
     */
    function isLong(obj) {
        return (obj && obj["__isLong__"]) === true;
    }

    /**
     * Tests if the specified object is a Long.
     * @function
     * @param {*} obj Object
     * @returns {boolean}
     */
    Long.isLong = isLong;

    /**
     * A cache of the Long representations of small integer values.
     * @type {!Object}
     * @inner
     */
    var INT_CACHE = {};

    /**
     * A cache of the Long representations of small unsigned integer values.
     * @type {!Object}
     * @inner
     */
    var UINT_CACHE = {};

    /**
     * @param {number} value
     * @param {boolean=} unsigned
     * @returns {!Long}
     * @inner
     */
    function fromInt(value, unsigned) {
        var obj, cachedObj, cache;
        if (unsigned) {
            value >>>= 0;
            if (cache = (0 <= value && value < 256)) {
                cachedObj = UINT_CACHE[value];
                if (cachedObj)
                    return cachedObj;
            }
            obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true);
            if (cache)
                UINT_CACHE[value] = obj;
            return obj;
        } else {
            value |= 0;
            if (cache = (-128 <= value && value < 128)) {
                cachedObj = INT_CACHE[value];
                if (cachedObj)
                    return cachedObj;
            }
            obj = fromBits(value, value < 0 ? -1 : 0, false);
            if (cache)
                INT_CACHE[value] = obj;
            return obj;
        }
    }

    /**
     * Returns a Long representing the given 32 bit integer value.
     * @function
     * @param {number} value The 32 bit integer in question
     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
     * @returns {!Long} The corresponding Long value
     */
    Long.fromInt = fromInt;

    /**
     * @param {number} value
     * @param {boolean=} unsigned
     * @returns {!Long}
     * @inner
     */
    function fromNumber(value, unsigned) {
        if (isNaN(value) || !isFinite(value))
            return unsigned ? UZERO : ZERO;
        if (unsigned) {
            if (value < 0)
                return UZERO;
            if (value >= TWO_PWR_64_DBL)
                return MAX_UNSIGNED_VALUE;
        } else {
            if (value <= -TWO_PWR_63_DBL)
                return MIN_VALUE;
            if (value + 1 >= TWO_PWR_63_DBL)
                return MAX_VALUE;
        }
        if (value < 0)
            return fromNumber(-value, unsigned).neg();
        return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);
    }

    /**
     * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.
     * @function
     * @param {number} value The number in question
     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
     * @returns {!Long} The corresponding Long value
     */
    Long.fromNumber = fromNumber;

    /**
     * @param {number} lowBits
     * @param {number} highBits
     * @param {boolean=} unsigned
     * @returns {!Long}
     * @inner
     */
    function fromBits(lowBits, highBits, unsigned) {
        return new Long(lowBits, highBits, unsigned);
    }

    /**
     * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is
     *  assumed to use 32 bits.
     * @function
     * @param {number} lowBits The low 32 bits
     * @param {number} highBits The high 32 bits
     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
     * @returns {!Long} The corresponding Long value
     */
    Long.fromBits = fromBits;

    /**
     * @function
     * @param {number} base
     * @param {number} exponent
     * @returns {number}
     * @inner
     */
    var pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4)

    /**
     * @param {string} str
     * @param {(boolean|number)=} unsigned
     * @param {number=} radix
     * @returns {!Long}
     * @inner
     */
    function fromString(str, unsigned, radix) {
        if (str.length === 0)
            throw Error('empty string');
        if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity")
            return ZERO;
        if (typeof unsigned === 'number') {
            // For goog.math.long compatibility
            radix = unsigned,
            unsigned = false;
        } else {
            unsigned = !! unsigned;
        }
        radix = radix || 10;
        if (radix < 2 || 36 < radix)
            throw RangeError('radix');

        var p;
        if ((p = str.indexOf('-')) > 0)
            throw Error('interior hyphen');
        else if (p === 0) {
            return fromString(str.substring(1), unsigned, radix).neg();
        }

        // Do several (8) digits each time through the loop, so as to
        // minimize the calls to the very expensive emulated div.
        var radixToPower = fromNumber(pow_dbl(radix, 8));

        var result = ZERO;
        for (var i = 0; i < str.length; i += 8) {
            var size = Math.min(8, str.length - i),
                value = parseInt(str.substring(i, i + size), radix);
            if (size < 8) {
                var power = fromNumber(pow_dbl(radix, size));
                result = result.mul(power).add(fromNumber(value));
            } else {
                result = result.mul(radixToPower);
                result = result.add(fromNumber(value));
            }
        }
        result.unsigned = unsigned;
        return result;
    }

    /**
     * Returns a Long representation of the given string, written using the specified radix.
     * @function
     * @param {string} str The textual representation of the Long
     * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to `false` for signed
     * @param {number=} radix The radix in which the text is written (2-36), defaults to 10
     * @returns {!Long} The corresponding Long value
     */
    Long.fromString = fromString;

    /**
     * @function
     * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val
     * @returns {!Long}
     * @inner
     */
    function fromValue(val) {
        if (val /* is compatible */ instanceof Long)
            return val;
        if (typeof val === 'number')
            return fromNumber(val);
        if (typeof val === 'string')
            return fromString(val);
        // Throws for non-objects, converts non-instanceof Long:
        return fromBits(val.low, val.high, val.unsigned);
    }

    /**
     * Converts the specified value to a Long.
     * @function
     * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value
     * @returns {!Long}
     */
    Long.fromValue = fromValue;

    // NOTE: the compiler should inline these constant values below and then remove these variables, so there should be
    // no runtime penalty for these.

    /**
     * @type {number}
     * @const
     * @inner
     */
    var TWO_PWR_16_DBL = 1 << 16;

    /**
     * @type {number}
     * @const
     * @inner
     */
    var TWO_PWR_24_DBL = 1 << 24;

    /**
     * @type {number}
     * @const
     * @inner
     */
    var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;

    /**
     * @type {number}
     * @const
     * @inner
     */
    var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;

    /**
     * @type {number}
     * @const
     * @inner
     */
    var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;

    /**
     * @type {!Long}
     * @const
     * @inner
     */
    var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);

    /**
     * @type {!Long}
     * @inner
     */
    var ZERO = fromInt(0);

    /**
     * Signed zero.
     * @type {!Long}
     */
    Long.ZERO = ZERO;

    /**
     * @type {!Long}
     * @inner
     */
    var UZERO = fromInt(0, true);

    /**
     * Unsigned zero.
     * @type {!Long}
     */
    Long.UZERO = UZERO;

    /**
     * @type {!Long}
     * @inner
     */
    var ONE = fromInt(1);

    /**
     * Signed one.
     * @type {!Long}
     */
    Long.ONE = ONE;

    /**
     * @type {!Long}
     * @inner
     */
    var UONE = fromInt(1, true);

    /**
     * Unsigned one.
     * @type {!Long}
     */
    Long.UONE = UONE;

    /**
     * @type {!Long}
     * @inner
     */
    var NEG_ONE = fromInt(-1);

    /**
     * Signed negative one.
     * @type {!Long}
     */
    Long.NEG_ONE = NEG_ONE;

    /**
     * @type {!Long}
     * @inner
     */
    var MAX_VALUE = fromBits(0xFFFFFFFF|0, 0x7FFFFFFF|0, false);

    /**
     * Maximum signed value.
     * @type {!Long}
     */
    Long.MAX_VALUE = MAX_VALUE;

    /**
     * @type {!Long}
     * @inner
     */
    var MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF|0, 0xFFFFFFFF|0, true);

    /**
     * Maximum unsigned value.
     * @type {!Long}
     */
    Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;

    /**
     * @type {!Long}
     * @inner
     */
    var MIN_VALUE = fromBits(0, 0x80000000|0, false);

    /**
     * Minimum signed value.
     * @type {!Long}
     */
    Long.MIN_VALUE = MIN_VALUE;

    /**
     * @alias Long.prototype
     * @inner
     */
    var LongPrototype = Long.prototype;

    /**
     * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.
     * @returns {number}
     */
    LongPrototype.toInt = function toInt() {
        return this.unsigned ? this.low >>> 0 : this.low;
    };

    /**
     * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).
     * @returns {number}
     */
    LongPrototype.toNumber = function toNumber() {
        if (this.unsigned)
            return ((this.high >>> 0) * TWO_PWR_32_DBL) + (this.low >>> 0);
        return this.high * TWO_PWR_32_DBL + (this.low >>> 0);
    };

    /**
     * Converts the Long to a string written in the specified radix.
     * @param {number=} radix Radix (2-36), defaults to 10
     * @returns {string}
     * @override
     * @throws {RangeError} If `radix` is out of range
     */
    LongPrototype.toString = function toString(radix) {
        radix = radix || 10;
        if (radix < 2 || 36 < radix)
            throw RangeError('radix');
        if (this.isZero())
            return '0';
        if (this.isNegative()) { // Unsigned Longs are never negative
            if (this.eq(MIN_VALUE)) {
                // We need to change the Long value before it can be negated, so we remove
                // the bottom-most digit in this base and then recurse to do the rest.
                var radixLong = fromNumber(radix),
                    div = this.div(radixLong),
                    rem1 = div.mul(radixLong).sub(this);
                return div.toString(radix) + rem1.toInt().toString(radix);
            } else
                return '-' + this.neg().toString(radix);
        }

        // Do several (6) digits each time through the loop, so as to
        // minimize the calls to the very expensive emulated div.
        var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned),
            rem = this;
        var result = '';
        while (true) {
            var remDiv = rem.div(radixToPower),
                intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0,
                digits = intval.toString(radix);
            rem = remDiv;
            if (rem.isZero())
                return digits + result;
            else {
                while (digits.length < 6)
                    digits = '0' + digits;
                result = '' + digits + result;
            }
        }
    };

    /**
     * Gets the high 32 bits as a signed integer.
     * @returns {number} Signed high bits
     */
    LongPrototype.getHighBits = function getHighBits() {
        return this.high;
    };

    /**
     * Gets the high 32 bits as an unsigned integer.
     * @returns {number} Unsigned high bits
     */
    LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {
        return this.high >>> 0;
    };

    /**
     * Gets the low 32 bits as a signed integer.
     * @returns {number} Signed low bits
     */
    LongPrototype.getLowBits = function getLowBits() {
        return this.low;
    };

    /**
     * Gets the low 32 bits as an unsigned integer.
     * @returns {number} Unsigned low bits
     */
    LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {
        return this.low >>> 0;
    };

    /**
     * Gets the number of bits needed to represent the absolute value of this Long.
     * @returns {number}
     */
    LongPrototype.getNumBitsAbs = function getNumBitsAbs() {
        if (this.isNegative()) // Unsigned Longs are never negative
            return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();
        var val = this.high != 0 ? this.high : this.low;
        for (var bit = 31; bit > 0; bit--)
            if ((val & (1 << bit)) != 0)
                break;
        return this.high != 0 ? bit + 33 : bit + 1;
    };

    /**
     * Tests if this Long's value equals zero.
     * @returns {boolean}
     */
    LongPrototype.isZero = function isZero() {
        return this.high === 0 && this.low === 0;
    };

    /**
     * Tests if this Long's value is negative.
     * @returns {boolean}
     */
    LongPrototype.isNegative = function isNegative() {
        return !this.unsigned && this.high < 0;
    };

    /**
     * Tests if this Long's value is positive.
     * @returns {boolean}
     */
    LongPrototype.isPositive = function isPositive() {
        return this.unsigned || this.high >= 0;
    };

    /**
     * Tests if this Long's value is odd.
     * @returns {boolean}
     */
    LongPrototype.isOdd = function isOdd() {
        return (this.low & 1) === 1;
    };

    /**
     * Tests if this Long's value is even.
     * @returns {boolean}
     */
    LongPrototype.isEven = function isEven() {
        return (this.low & 1) === 0;
    };

    /**
     * Tests if this Long's value equals the specified's.
     * @param {!Long|number|string} other Other value
     * @returns {boolean}
     */
    LongPrototype.equals = function equals(other) {
        if (!isLong(other))
            other = fromValue(other);
        if (this.unsigned !== other.unsigned && (this.high >>> 31) === 1 && (other.high >>> 31) === 1)
            return false;
        return this.high === other.high && this.low === other.low;
    };

    /**
     * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.
     * @function
     * @param {!Long|number|string} other Other value
     * @returns {boolean}
     */
    LongPrototype.eq = LongPrototype.equals;

    /**
     * Tests if this Long's value differs from the specified's.
     * @param {!Long|number|string} other Other value
     * @returns {boolean}
     */
    LongPrototype.notEquals = function notEquals(other) {
        return !this.eq(/* validates */ other);
    };

    /**
     * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.
     * @function
     * @param {!Long|number|string} other Other value
     * @returns {boolean}
     */
    LongPrototype.neq = LongPrototype.notEquals;

    /**
     * Tests if this Long's value is less than the specified's.
     * @param {!Long|number|string} other Other value
     * @returns {boolean}
     */
    LongPrototype.lessThan = function lessThan(other) {
        return this.comp(/* validates */ other) < 0;
    };

    /**
     * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.
     * @function
     * @param {!Long|number|string} other Other value
     * @returns {boolean}
     */
    LongPrototype.lt = LongPrototype.lessThan;

    /**
     * Tests if this Long's value is less than or equal the specified's.
     * @param {!Long|number|string} other Other value
     * @returns {boolean}
     */
    LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {
        return this.comp(/* validates */ other) <= 0;
    };

    /**
     * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.
     * @function
     * @param {!Long|number|string} other Other value
     * @returns {boolean}
     */
    LongPrototype.lte = LongPrototype.lessThanOrEqual;

    /**
     * Tests if this Long's value is greater than the specified's.
     * @param {!Long|number|string} other Other value
     * @returns {boolean}
     */
    LongPrototype.greaterThan = function greaterThan(other) {
        return this.comp(/* validates */ other) > 0;
    };

    /**
     * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.
     * @function
     * @param {!Long|number|string} other Other value
     * @returns {boolean}
     */
    LongPrototype.gt = LongPrototype.greaterThan;

    /**
     * Tests if this Long's value is greater than or equal the specified's.
     * @param {!Long|number|string} other Other value
     * @returns {boolean}
     */
    LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {
        return this.comp(/* validates */ other) >= 0;
    };

    /**
     * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.
     * @function
     * @param {!Long|number|string} other Other value
     * @returns {boolean}
     */
    LongPrototype.gte = LongPrototype.greaterThanOrEqual;

    /**
     * Compares this Long's value with the specified's.
     * @param {!Long|number|string} other Other value
     * @returns {number} 0 if they are the same, 1 if the this is greater and -1
     *  if the given one is greater
     */
    LongPrototype.compare = function compare(other) {
        if (!isLong(other))
            other = fromValue(other);
        if (this.eq(other))
            return 0;
        var thisNeg = this.isNegative(),
            otherNeg = other.isNegative();
        if (thisNeg && !otherNeg)
            return -1;
        if (!thisNeg && otherNeg)
            return 1;
        // At this point the sign bits are the same
        if (!this.unsigned)
            return this.sub(other).isNegative() ? -1 : 1;
        // Both are positive if at least one is unsigned
        return (other.high >>> 0) > (this.high >>> 0) || (other.high === this.high && (other.low >>> 0) > (this.low >>> 0)) ? -1 : 1;
    };

    /**
     * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.
     * @function
     * @param {!Long|number|string} other Other value
     * @returns {number} 0 if they are the same, 1 if the this is greater and -1
     *  if the given one is greater
     */
    LongPrototype.comp = LongPrototype.compare;

    /**
     * Negates this Long's value.
     * @returns {!Long} Negated Long
     */
    LongPrototype.negate = function negate() {
        if (!this.unsigned && this.eq(MIN_VALUE))
            return MIN_VALUE;
        return this.not().add(ONE);
    };

    /**
     * Negates this Long's value. This is an alias of {@link Long#negate}.
     * @function
     * @returns {!Long} Negated Long
     */
    LongPrototype.neg = LongPrototype.negate;

    /**
     * Returns the sum of this and the specified Long.
     * @param {!Long|number|string} addend Addend
     * @returns {!Long} Sum
     */
    LongPrototype.add = function add(addend) {
        if (!isLong(addend))
            addend = fromValue(addend);

        // Divide each number into 4 chunks of 16 bits, and then sum the chunks.

        var a48 = this.high >>> 16;
        var a32 = this.high & 0xFFFF;
        var a16 = this.low >>> 16;
        var a00 = this.low & 0xFFFF;

        var b48 = addend.high >>> 16;
        var b32 = addend.high & 0xFFFF;
        var b16 = addend.low >>> 16;
        var b00 = addend.low & 0xFFFF;

        var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
        c00 += a00 + b00;
        c16 += c00 >>> 16;
        c00 &= 0xFFFF;
        c16 += a16 + b16;
        c32 += c16 >>> 16;
        c16 &= 0xFFFF;
        c32 += a32 + b32;
        c48 += c32 >>> 16;
        c32 &= 0xFFFF;
        c48 += a48 + b48;
        c48 &= 0xFFFF;
        return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);
    };

    /**
     * Returns the difference of this and the specified Long.
     * @param {!Long|number|string} subtrahend Subtrahend
     * @returns {!Long} Difference
     */
    LongPrototype.subtract = function subtract(subtrahend) {
        if (!isLong(subtrahend))
            subtrahend = fromValue(subtrahend);
        return this.add(subtrahend.neg());
    };

    /**
     * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.
     * @function
     * @param {!Long|number|string} subtrahend Subtrahend
     * @returns {!Long} Difference
     */
    LongPrototype.sub = LongPrototype.subtract;

    /**
     * Returns the product of this and the specified Long.
     * @param {!Long|number|string} multiplier Multiplier
     * @returns {!Long} Product
     */
    LongPrototype.multiply = function multiply(multiplier) {
        if (this.isZero())
            return ZERO;
        if (!isLong(multiplier))
            multiplier = fromValue(multiplier);
        if (multiplier.isZero())
            return ZERO;
        if (this.eq(MIN_VALUE))
            return multiplier.isOdd() ? MIN_VALUE : ZERO;
        if (multiplier.eq(MIN_VALUE))
            return this.isOdd() ? MIN_VALUE : ZERO;

        if (this.isNegative()) {
            if (multiplier.isNegative())
                return this.neg().mul(multiplier.neg());
            else
                return this.neg().mul(multiplier).neg();
        } else if (multiplier.isNegative())
            return this.mul(multiplier.neg()).neg();

        // If both longs are small, use float multiplication
        if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))
            return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);

        // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.
        // We can skip products that would overflow.

        var a48 = this.high >>> 16;
        var a32 = this.high & 0xFFFF;
        var a16 = this.low >>> 16;
        var a00 = this.low & 0xFFFF;

        var b48 = multiplier.high >>> 16;
        var b32 = multiplier.high & 0xFFFF;
        var b16 = multiplier.low >>> 16;
        var b00 = multiplier.low & 0xFFFF;

        var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
        c00 += a00 * b00;
        c16 += c00 >>> 16;
        c00 &= 0xFFFF;
        c16 += a16 * b00;
        c32 += c16 >>> 16;
        c16 &= 0xFFFF;
        c16 += a00 * b16;
        c32 += c16 >>> 16;
        c16 &= 0xFFFF;
        c32 += a32 * b00;
        c48 += c32 >>> 16;
        c32 &= 0xFFFF;
        c32 += a16 * b16;
        c48 += c32 >>> 16;
        c32 &= 0xFFFF;
        c32 += a00 * b32;
        c48 += c32 >>> 16;
        c32 &= 0xFFFF;
        c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
        c48 &= 0xFFFF;
        return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);
    };

    /**
     * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.
     * @function
     * @param {!Long|number|string} multiplier Multiplier
     * @returns {!Long} Product
     */
    LongPrototype.mul = LongPrototype.multiply;

    /**
     * Returns this Long divided by the specified. The result is signed if this Long is signed or
     *  unsigned if this Long is unsigned.
     * @param {!Long|number|string} divisor Divisor
     * @returns {!Long} Quotient
     */
    LongPrototype.divide = function divide(divisor) {
        if (!isLong(divisor))
            divisor = fromValue(divisor);
        if (divisor.isZero())
            throw Error('division by zero');
        if (this.isZero())
            return this.unsigned ? UZERO : ZERO;
        var approx, rem, res;
        if (!this.unsigned) {
            // This section is only relevant for signed longs and is derived from the
            // closure library as a whole.
            if (this.eq(MIN_VALUE)) {
                if (divisor.eq(ONE) || divisor.eq(NEG_ONE))
                    return MIN_VALUE;  // recall that -MIN_VALUE == MIN_VALUE
                else if (divisor.eq(MIN_VALUE))
                    return ONE;
                else {
                    // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.
                    var halfThis = this.shr(1);
                    approx = halfThis.div(divisor).shl(1);
                    if (approx.eq(ZERO)) {
                        return divisor.isNegative() ? ONE : NEG_ONE;
                    } else {
                        rem = this.sub(divisor.mul(approx));
                        res = approx.add(rem.div(divisor));
                        return res;
                    }
                }
            } else if (divisor.eq(MIN_VALUE))
                return this.unsigned ? UZERO : ZERO;
            if (this.isNegative()) {
                if (divisor.isNegative())
                    return this.neg().div(divisor.neg());
                return this.neg().div(divisor).neg();
            } else if (divisor.isNegative())
                return this.div(divisor.neg()).neg();
            res = ZERO;
        } else {
            // The algorithm below has not been made for unsigned longs. It's therefore
            // required to take special care of the MSB prior to running it.
            if (!divisor.unsigned)
                divisor = divisor.toUnsigned();
            if (divisor.gt(this))
                return UZERO;
            if (divisor.gt(this.shru(1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true
                return UONE;
            res = UZERO;
        }

        // Repeat the following until the remainder is less than other:  find a
        // floating-point that approximates remainder / other *from below*, add this
        // into the result, and subtract it from the remainder.  It is critical that
        // the approximate value is less than or equal to the real value so that the
        // remainder never becomes negative.
        rem = this;
        while (rem.gte(divisor)) {
            // Approximate the result of division. This may be a little greater or
            // smaller than the actual value.
            approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));

            // We will tweak the approximate result by changing it in the 48-th digit or
            // the smallest non-fractional digit, whichever is larger.
            var log2 = Math.ceil(Math.log(approx) / Math.LN2),
                delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48),

            // Decrease the approximation until it is smaller than the remainder.  Note
            // that if it is too large, the product overflows and is negative.
                approxRes = fromNumber(approx),
                approxRem = approxRes.mul(divisor);
            while (approxRem.isNegative() || approxRem.gt(rem)) {
                approx -= delta;
                approxRes = fromNumber(approx, this.unsigned);
                approxRem = approxRes.mul(divisor);
            }

            // We know the answer can't be zero... and actually, zero would cause
            // infinite recursion since we would make no progress.
            if (approxRes.isZero())
                approxRes = ONE;

            res = res.add(approxRes);
            rem = rem.sub(approxRem);
        }
        return res;
    };

    /**
     * Returns this Long divided by the specified. This is an alias of {@link Long#divide}.
     * @function
     * @param {!Long|number|string} divisor Divisor
     * @returns {!Long} Quotient
     */
    LongPrototype.div = LongPrototype.divide;

    /**
     * Returns this Long modulo the specified.
     * @param {!Long|number|string} divisor Divisor
     * @returns {!Long} Remainder
     */
    LongPrototype.modulo = function modulo(divisor) {
        if (!isLong(divisor))
            divisor = fromValue(divisor);
        return this.sub(this.div(divisor).mul(divisor));
    };

    /**
     * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.
     * @function
     * @param {!Long|number|string} divisor Divisor
     * @returns {!Long} Remainder
     */
    LongPrototype.mod = LongPrototype.modulo;

    /**
     * Returns the bitwise NOT of this Long.
     * @returns {!Long}
     */
    LongPrototype.not = function not() {
        return fromBits(~this.low, ~this.high, this.unsigned);
    };

    /**
     * Returns the bitwise AND of this Long and the specified.
     * @param {!Long|number|string} other Other Long
     * @returns {!Long}
     */
    LongPrototype.and = function and(other) {
        if (!isLong(other))
            other = fromValue(other);
        return fromBits(this.low & other.low, this.high & other.high, this.unsigned);
    };

    /**
     * Returns the bitwise OR of this Long and the specified.
     * @param {!Long|number|string} other Other Long
     * @returns {!Long}
     */
    LongPrototype.or = function or(other) {
        if (!isLong(other))
            other = fromValue(other);
        return fromBits(this.low | other.low, this.high | other.high, this.unsigned);
    };

    /**
     * Returns the bitwise XOR of this Long and the given one.
     * @param {!Long|number|string} other Other Long
     * @returns {!Long}
     */
    LongPrototype.xor = function xor(other) {
        if (!isLong(other))
            other = fromValue(other);
        return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);
    };

    /**
     * Returns this Long with bits shifted to the left by the given amount.
     * @param {number|!Long} numBits Number of bits
     * @returns {!Long} Shifted Long
     */
    LongPrototype.shiftLeft = function shiftLeft(numBits) {
        if (isLong(numBits))
            numBits = numBits.toInt();
        if ((numBits &= 63) === 0)
            return this;
        else if (numBits < 32)
            return fromBits(this.low << numBits, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned);
        else
            return fromBits(0, this.low << (numBits - 32), this.unsigned);
    };

    /**
     * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.
     * @function
     * @param {number|!Long} numBits Number of bits
     * @returns {!Long} Shifted Long
     */
    LongPrototype.shl = LongPrototype.shiftLeft;

    /**
     * Returns this Long with bits arithmetically shifted to the right by the given amount.
     * @param {number|!Long} numBits Number of bits
     * @returns {!Long} Shifted Long
     */
    LongPrototype.shiftRight = function shiftRight(numBits) {
        if (isLong(numBits))
            numBits = numBits.toInt();
        if ((numBits &= 63) === 0)
            return this;
        else if (numBits < 32)
            return fromBits((this.low >>> numBits) | (this.high << (32 - numBits)), this.high >> numBits, this.unsigned);
        else
            return fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned);
    };

    /**
     * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.
     * @function
     * @param {number|!Long} numBits Number of bits
     * @returns {!Long} Shifted Long
     */
    LongPrototype.shr = LongPrototype.shiftRight;

    /**
     * Returns this Long with bits logically shifted to the right by the given amount.
     * @param {number|!Long} numBits Number of bits
     * @returns {!Long} Shifted Long
     */
    LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {
        if (isLong(numBits))
            numBits = numBits.toInt();
        numBits &= 63;
        if (numBits === 0)
            return this;
        else {
            var high = this.high;
            if (numBits < 32) {
                var low = this.low;
                return fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, this.unsigned);
            } else if (numBits === 32)
                return fromBits(high, 0, this.unsigned);
            else
                return fromBits(high >>> (numBits - 32), 0, this.unsigned);
        }
    };

    /**
     * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.
     * @function
     * @param {number|!Long} numBits Number of bits
     * @returns {!Long} Shifted Long
     */
    LongPrototype.shru = LongPrototype.shiftRightUnsigned;

    /**
     * Converts this Long to signed.
     * @returns {!Long} Signed long
     */
    LongPrototype.toSigned = function toSigned() {
        if (!this.unsigned)
            return this;
        return fromBits(this.low, this.high, false);
    };

    /**
     * Converts this Long to unsigned.
     * @returns {!Long} Unsigned long
     */
    LongPrototype.toUnsigned = function toUnsigned() {
        if (this.unsigned)
            return this;
        return fromBits(this.low, this.high, true);
    };

    /**
     * Converts this Long to its byte representation.
     * @param {boolean=} le Whether little or big endian, defaults to big endian
     * @returns {!Array.<number>} Byte representation
     */
    LongPrototype.toBytes = function(le) {
        return le ? this.toBytesLE() : this.toBytesBE();
    }

    /**
     * Converts this Long to its little endian byte representation.
     * @returns {!Array.<number>} Little endian byte representation
     */
    LongPrototype.toBytesLE = function() {
        var hi = this.high,
            lo = this.low;
        return [
             lo         & 0xff,
            (lo >>>  8) & 0xff,
            (lo >>> 16) & 0xff,
            (lo >>> 24) & 0xff,
             hi         & 0xff,
            (hi >>>  8) & 0xff,
            (hi >>> 16) & 0xff,
            (hi >>> 24) & 0xff
        ];
    }

    /**
     * Converts this Long to its big endian byte representation.
     * @returns {!Array.<number>} Big endian byte representation
     */
    LongPrototype.toBytesBE = function() {
        var hi = this.high,
            lo = this.low;
        return [
            (hi >>> 24) & 0xff,
            (hi >>> 16) & 0xff,
            (hi >>>  8) & 0xff,
             hi         & 0xff,
            (lo >>> 24) & 0xff,
            (lo >>> 16) & 0xff,
            (lo >>>  8) & 0xff,
             lo         & 0xff
        ];
    }

    return Long;
});

},{}],713:[function(require,module,exports){
/*
object-assign
(c) Sindre Sorhus
@license MIT
*/

'use strict';
/* eslint-disable no-unused-vars */
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var propIsEnumerable = Object.prototype.propertyIsEnumerable;

function toObject(val) {
	if (val === null || val === undefined) {
		throw new TypeError('Object.assign cannot be called with null or undefined');
	}

	return Object(val);
}

function shouldUseNative() {
	try {
		if (!Object.assign) {
			return false;
		}

		// Detect buggy property enumeration order in older V8 versions.

		// https://bugs.chromium.org/p/v8/issues/detail?id=4118
		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
		test1[5] = 'de';
		if (Object.getOwnPropertyNames(test1)[0] === '5') {
			return false;
		}

		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
		var test2 = {};
		for (var i = 0; i < 10; i++) {
			test2['_' + String.fromCharCode(i)] = i;
		}
		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
			return test2[n];
		});
		if (order2.join('') !== '0123456789') {
			return false;
		}

		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
		var test3 = {};
		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
			test3[letter] = letter;
		});
		if (Object.keys(Object.assign({}, test3)).join('') !==
				'abcdefghijklmnopqrst') {
			return false;
		}

		return true;
	} catch (err) {
		// We don't expect any of the above to throw, but better to be safe.
		return false;
	}
}

module.exports = shouldUseNative() ? Object.assign : function (target, source) {
	var from;
	var to = toObject(target);
	var symbols;

	for (var s = 1; s < arguments.length; s++) {
		from = Object(arguments[s]);

		for (var key in from) {
			if (hasOwnProperty.call(from, key)) {
				to[key] = from[key];
			}
		}

		if (getOwnPropertySymbols) {
			symbols = getOwnPropertySymbols(from);
			for (var i = 0; i < symbols.length; i++) {
				if (propIsEnumerable.call(from, symbols[i])) {
					to[symbols[i]] = from[symbols[i]];
				}
			}
		}
	}

	return to;
};

},{}],714:[function(require,module,exports){
// shim for using process in browser
var process = module.exports = {};

// cached from whatever global is present so that test runners that stub it
// don't break things.  But we need to wrap it in a try catch in case it is
// wrapped in strict mode code which doesn't define any globals.  It's inside a
// function because try/catches deoptimize in certain engines.

var cachedSetTimeout;
var cachedClearTimeout;

function defaultSetTimout() {
    throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout () {
    throw new Error('clearTimeout has not been defined');
}
(function () {
    try {
        if (typeof setTimeout === 'function') {
            cachedSetTimeout = setTimeout;
        } else {
            cachedSetTimeout = defaultSetTimout;
        }
    } catch (e) {
        cachedSetTimeout = defaultSetTimout;
    }
    try {
        if (typeof clearTimeout === 'function') {
            cachedClearTimeout = clearTimeout;
        } else {
            cachedClearTimeout = defaultClearTimeout;
        }
    } catch (e) {
        cachedClearTimeout = defaultClearTimeout;
    }
} ())
function runTimeout(fun) {
    if (cachedSetTimeout === setTimeout) {
        //normal enviroments in sane situations
        return setTimeout(fun, 0);
    }
    // if setTimeout wasn't available but was latter defined
    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
        cachedSetTimeout = setTimeout;
        return setTimeout(fun, 0);
    }
    try {
        // when when somebody has screwed with setTimeout but no I.E. maddness
        return cachedSetTimeout(fun, 0);
    } catch(e){
        try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
            return cachedSetTimeout.call(null, fun, 0);
        } catch(e){
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
            return cachedSetTimeout.call(this, fun, 0);
        }
    }


}
function runClearTimeout(marker) {
    if (cachedClearTimeout === clearTimeout) {
        //normal enviroments in sane situations
        return clearTimeout(marker);
    }
    // if clearTimeout wasn't available but was latter defined
    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
        cachedClearTimeout = clearTimeout;
        return clearTimeout(marker);
    }
    try {
        // when when somebody has screwed with setTimeout but no I.E. maddness
        return cachedClearTimeout(marker);
    } catch (e){
        try {
            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
            return cachedClearTimeout.call(null, marker);
        } catch (e){
            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
            return cachedClearTimeout.call(this, marker);
        }
    }



}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;

function cleanUpNextTick() {
    if (!draining || !currentQueue) {
        return;
    }
    draining = false;
    if (currentQueue.length) {
        queue = currentQueue.concat(queue);
    } else {
        queueIndex = -1;
    }
    if (queue.length) {
        drainQueue();
    }
}

function drainQueue() {
    if (draining) {
        return;
    }
    var timeout = runTimeout(cleanUpNextTick);
    draining = true;

    var len = queue.length;
    while(len) {
        currentQueue = queue;
        queue = [];
        while (++queueIndex < len) {
            if (currentQueue) {
                currentQueue[queueIndex].run();
            }
        }
        queueIndex = -1;
        len = queue.length;
    }
    currentQueue = null;
    draining = false;
    runClearTimeout(timeout);
}

process.nextTick = function (fun) {
    var args = new Array(arguments.length - 1);
    if (arguments.length > 1) {
        for (var i = 1; i < arguments.length; i++) {
            args[i - 1] = arguments[i];
        }
    }
    queue.push(new Item(fun, args));
    if (queue.length === 1 && !draining) {
        runTimeout(drainQueue);
    }
};

// v8 likes predictible objects
function Item(fun, array) {
    this.fun = fun;
    this.array = array;
}
Item.prototype.run = function () {
    this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};

function noop() {}

process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.prependListener = noop;
process.prependOnceListener = noop;

process.listeners = function (name) { return [] }

process.binding = function (name) {
    throw new Error('process.binding is not supported');
};

process.cwd = function () { return '/' };
process.chdir = function (dir) {
    throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };

},{}],715:[function(require,module,exports){
// minimal library entry point.

"use strict";
module.exports = require("./src/index-minimal");

},{"./src/index-minimal":716}],716:[function(require,module,exports){
"use strict";
var protobuf = exports;

/**
 * Build type, one of `"full"`, `"light"` or `"minimal"`.
 * @name build
 * @type {string}
 * @const
 */
protobuf.build = "minimal";

// Serialization
protobuf.Writer       = require("./writer");
protobuf.BufferWriter = require("./writer_buffer");
protobuf.Reader       = require("./reader");
protobuf.BufferReader = require("./reader_buffer");

// Utility
protobuf.util         = require("./util/minimal");
protobuf.rpc          = require("./rpc");
protobuf.roots        = require("./roots");
protobuf.configure    = configure;

/* istanbul ignore next */
/**
 * Reconfigures the library according to the environment.
 * @returns {undefined}
 */
function configure() {
    protobuf.util._configure();
    protobuf.Writer._configure(protobuf.BufferWriter);
    protobuf.Reader._configure(protobuf.BufferReader);
}

// Set up buffer utility according to the environment
configure();

},{"./reader":717,"./reader_buffer":718,"./roots":719,"./rpc":720,"./util/minimal":723,"./writer":724,"./writer_buffer":725}],717:[function(require,module,exports){
"use strict";
module.exports = Reader;

var util      = require("./util/minimal");

var BufferReader; // cyclic

var LongBits  = util.LongBits,
    utf8      = util.utf8;

/* istanbul ignore next */
function indexOutOfRange(reader, writeLength) {
    return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
}

/**
 * Constructs a new reader instance using the specified buffer.
 * @classdesc Wire format reader using `Uint8Array` if available, otherwise `Array`.
 * @constructor
 * @param {Uint8Array} buffer Buffer to read from
 */
function Reader(buffer) {

    /**
     * Read buffer.
     * @type {Uint8Array}
     */
    this.buf = buffer;

    /**
     * Read buffer position.
     * @type {number}
     */
    this.pos = 0;

    /**
     * Read buffer length.
     * @type {number}
     */
    this.len = buffer.length;
}

var create_array = typeof Uint8Array !== "undefined"
    ? function create_typed_array(buffer) {
        if (buffer instanceof Uint8Array || Array.isArray(buffer))
            return new Reader(buffer);
        throw Error("illegal buffer");
    }
    /* istanbul ignore next */
    : function create_array(buffer) {
        if (Array.isArray(buffer))
            return new Reader(buffer);
        throw Error("illegal buffer");
    };

var create = function create() {
    return util.Buffer
        ? function create_buffer_setup(buffer) {
            return (Reader.create = function create_buffer(buffer) {
                return util.Buffer.isBuffer(buffer)
                    ? new BufferReader(buffer)
                    /* istanbul ignore next */
                    : create_array(buffer);
            })(buffer);
        }
        /* istanbul ignore next */
        : create_array;
};

/**
 * Creates a new reader using the specified buffer.
 * @function
 * @param {Uint8Array|Buffer} buffer Buffer to read from
 * @returns {Reader|BufferReader} A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}
 * @throws {Error} If `buffer` is not a valid buffer
 */
Reader.create = create();

Reader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */ util.Array.prototype.slice;

/**
 * Reads a varint as an unsigned 32 bit value.
 * @function
 * @returns {number} Value read
 */
Reader.prototype.uint32 = (function read_uint32_setup() {
    var value = 4294967295; // optimizer type-hint, tends to deopt otherwise (?!)
    return function read_uint32() {
        value = (         this.buf[this.pos] & 127       ) >>> 0; if (this.buf[this.pos++] < 128) return value;
        value = (value | (this.buf[this.pos] & 127) <<  7) >>> 0; if (this.buf[this.pos++] < 128) return value;
        value = (value | (this.buf[this.pos] & 127) << 14) >>> 0; if (this.buf[this.pos++] < 128) return value;
        value = (value | (this.buf[this.pos] & 127) << 21) >>> 0; if (this.buf[this.pos++] < 128) return value;
        value = (value | (this.buf[this.pos] &  15) << 28) >>> 0; if (this.buf[this.pos++] < 128) return value;

        /* istanbul ignore if */
        if ((this.pos += 5) > this.len) {
            this.pos = this.len;
            throw indexOutOfRange(this, 10);
        }
        return value;
    };
})();

/**
 * Reads a varint as a signed 32 bit value.
 * @returns {number} Value read
 */
Reader.prototype.int32 = function read_int32() {
    return this.uint32() | 0;
};

/**
 * Reads a zig-zag encoded varint as a signed 32 bit value.
 * @returns {number} Value read
 */
Reader.prototype.sint32 = function read_sint32() {
    var value = this.uint32();
    return value >>> 1 ^ -(value & 1) | 0;
};

/* eslint-disable no-invalid-this */

function readLongVarint() {
    // tends to deopt with local vars for octet etc.
    var bits = new LongBits(0, 0);
    var i = 0;
    if (this.len - this.pos > 4) { // fast route (lo)
        for (; i < 4; ++i) {
            // 1st..4th
            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
            if (this.buf[this.pos++] < 128)
                return bits;
        }
        // 5th
        bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
        bits.hi = (bits.hi | (this.buf[this.pos] & 127) >>  4) >>> 0;
        if (this.buf[this.pos++] < 128)
            return bits;
        i = 0;
    } else {
        for (; i < 3; ++i) {
            /* istanbul ignore if */
            if (this.pos >= this.len)
                throw indexOutOfRange(this);
            // 1st..3th
            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
            if (this.buf[this.pos++] < 128)
                return bits;
        }
        // 4th
        bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
        return bits;
    }
    if (this.len - this.pos > 4) { // fast route (hi)
        for (; i < 5; ++i) {
            // 6th..10th
            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
            if (this.buf[this.pos++] < 128)
                return bits;
        }
    } else {
        for (; i < 5; ++i) {
            /* istanbul ignore if */
            if (this.pos >= this.len)
                throw indexOutOfRange(this);
            // 6th..10th
            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
            if (this.buf[this.pos++] < 128)
                return bits;
        }
    }
    /* istanbul ignore next */
    throw Error("invalid varint encoding");
}

/* eslint-enable no-invalid-this */

/**
 * Reads a varint as a signed 64 bit value.
 * @name Reader#int64
 * @function
 * @returns {Long} Value read
 */

/**
 * Reads a varint as an unsigned 64 bit value.
 * @name Reader#uint64
 * @function
 * @returns {Long} Value read
 */

/**
 * Reads a zig-zag encoded varint as a signed 64 bit value.
 * @name Reader#sint64
 * @function
 * @returns {Long} Value read
 */

/**
 * Reads a varint as a boolean.
 * @returns {boolean} Value read
 */
Reader.prototype.bool = function read_bool() {
    return this.uint32() !== 0;
};

function readFixed32_end(buf, end) { // note that this uses `end`, not `pos`
    return (buf[end - 4]
          | buf[end - 3] << 8
          | buf[end - 2] << 16
          | buf[end - 1] << 24) >>> 0;
}

/**
 * Reads fixed 32 bits as an unsigned 32 bit integer.
 * @returns {number} Value read
 */
Reader.prototype.fixed32 = function read_fixed32() {

    /* istanbul ignore if */
    if (this.pos + 4 > this.len)
        throw indexOutOfRange(this, 4);

    return readFixed32_end(this.buf, this.pos += 4);
};

/**
 * Reads fixed 32 bits as a signed 32 bit integer.
 * @returns {number} Value read
 */
Reader.prototype.sfixed32 = function read_sfixed32() {

    /* istanbul ignore if */
    if (this.pos + 4 > this.len)
        throw indexOutOfRange(this, 4);

    return readFixed32_end(this.buf, this.pos += 4) | 0;
};

/* eslint-disable no-invalid-this */

function readFixed64(/* this: Reader */) {

    /* istanbul ignore if */
    if (this.pos + 8 > this.len)
        throw indexOutOfRange(this, 8);

    return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));
}

/* eslint-enable no-invalid-this */

/**
 * Reads fixed 64 bits.
 * @name Reader#fixed64
 * @function
 * @returns {Long} Value read
 */

/**
 * Reads zig-zag encoded fixed 64 bits.
 * @name Reader#sfixed64
 * @function
 * @returns {Long} Value read
 */

/**
 * Reads a float (32 bit) as a number.
 * @function
 * @returns {number} Value read
 */
Reader.prototype.float = function read_float() {

    /* istanbul ignore if */
    if (this.pos + 4 > this.len)
        throw indexOutOfRange(this, 4);

    var value = util.float.readFloatLE(this.buf, this.pos);
    this.pos += 4;
    return value;
};

/**
 * Reads a double (64 bit float) as a number.
 * @function
 * @returns {number} Value read
 */
Reader.prototype.double = function read_double() {

    /* istanbul ignore if */
    if (this.pos + 8 > this.len)
        throw indexOutOfRange(this, 4);

    var value = util.float.readDoubleLE(this.buf, this.pos);
    this.pos += 8;
    return value;
};

/**
 * Reads a sequence of bytes preceeded by its length as a varint.
 * @returns {Uint8Array} Value read
 */
Reader.prototype.bytes = function read_bytes() {
    var length = this.uint32(),
        start  = this.pos,
        end    = this.pos + length;

    /* istanbul ignore if */
    if (end > this.len)
        throw indexOutOfRange(this, length);

    this.pos += length;
    if (Array.isArray(this.buf)) // plain array
        return this.buf.slice(start, end);
    return start === end // fix for IE 10/Win8 and others' subarray returning array of size 1
        ? new this.buf.constructor(0)
        : this._slice.call(this.buf, start, end);
};

/**
 * Reads a string preceeded by its byte length as a varint.
 * @returns {string} Value read
 */
Reader.prototype.string = function read_string() {
    var bytes = this.bytes();
    return utf8.read(bytes, 0, bytes.length);
};

/**
 * Skips the specified number of bytes if specified, otherwise skips a varint.
 * @param {number} [length] Length if known, otherwise a varint is assumed
 * @returns {Reader} `this`
 */
Reader.prototype.skip = function skip(length) {
    if (typeof length === "number") {
        /* istanbul ignore if */
        if (this.pos + length > this.len)
            throw indexOutOfRange(this, length);
        this.pos += length;
    } else {
        do {
            /* istanbul ignore if */
            if (this.pos >= this.len)
                throw indexOutOfRange(this);
        } while (this.buf[this.pos++] & 128);
    }
    return this;
};

/**
 * Skips the next element of the specified wire type.
 * @param {number} wireType Wire type received
 * @returns {Reader} `this`
 */
Reader.prototype.skipType = function(wireType) {
    switch (wireType) {
        case 0:
            this.skip();
            break;
        case 1:
            this.skip(8);
            break;
        case 2:
            this.skip(this.uint32());
            break;
        case 3:
            while ((wireType = this.uint32() & 7) !== 4) {
                this.skipType(wireType);
            }
            break;
        case 5:
            this.skip(4);
            break;

        /* istanbul ignore next */
        default:
            throw Error("invalid wire type " + wireType + " at offset " + this.pos);
    }
    return this;
};

Reader._configure = function(BufferReader_) {
    BufferReader = BufferReader_;
    Reader.create = create();
    BufferReader._configure();

    var fn = util.Long ? "toLong" : /* istanbul ignore next */ "toNumber";
    util.merge(Reader.prototype, {

        int64: function read_int64() {
            return readLongVarint.call(this)[fn](false);
        },

        uint64: function read_uint64() {
            return readLongVarint.call(this)[fn](true);
        },

        sint64: function read_sint64() {
            return readLongVarint.call(this).zzDecode()[fn](false);
        },

        fixed64: function read_fixed64() {
            return readFixed64.call(this)[fn](true);
        },

        sfixed64: function read_sfixed64() {
            return readFixed64.call(this)[fn](false);
        }

    });
};

},{"./util/minimal":723}],718:[function(require,module,exports){
"use strict";
module.exports = BufferReader;

// extends Reader
var Reader = require("./reader");
(BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;

var util = require("./util/minimal");

/**
 * Constructs a new buffer reader instance.
 * @classdesc Wire format reader using node buffers.
 * @extends Reader
 * @constructor
 * @param {Buffer} buffer Buffer to read from
 */
function BufferReader(buffer) {
    Reader.call(this, buffer);

    /**
     * Read buffer.
     * @name BufferReader#buf
     * @type {Buffer}
     */
}

BufferReader._configure = function () {
    /* istanbul ignore else */
    if (util.Buffer)
        BufferReader.prototype._slice = util.Buffer.prototype.slice;
};


/**
 * @override
 */
BufferReader.prototype.string = function read_string_buffer() {
    var len = this.uint32(); // modifies pos
    return this.buf.utf8Slice
        ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len))
        : this.buf.toString("utf-8", this.pos, this.pos = Math.min(this.pos + len, this.len));
};

/**
 * Reads a sequence of bytes preceeded by its length as a varint.
 * @name BufferReader#bytes
 * @function
 * @returns {Buffer} Value read
 */

BufferReader._configure();

},{"./reader":717,"./util/minimal":723}],719:[function(require,module,exports){
"use strict";
module.exports = {};

/**
 * Named roots.
 * This is where pbjs stores generated structures (the option `-r, --root` specifies a name).
 * Can also be used manually to make roots available accross modules.
 * @name roots
 * @type {Object.<string,Root>}
 * @example
 * // pbjs -r myroot -o compiled.js ...
 *
 * // in another module:
 * require("./compiled.js");
 *
 * // in any subsequent module:
 * var root = protobuf.roots["myroot"];
 */

},{}],720:[function(require,module,exports){
"use strict";

/**
 * Streaming RPC helpers.
 * @namespace
 */
var rpc = exports;

/**
 * RPC implementation passed to {@link Service#create} performing a service request on network level, i.e. by utilizing http requests or websockets.
 * @typedef RPCImpl
 * @type {function}
 * @param {Method|rpc.ServiceMethod<Message<{}>,Message<{}>>} method Reflected or static method being called
 * @param {Uint8Array} requestData Request data
 * @param {RPCImplCallback} callback Callback function
 * @returns {undefined}
 * @example
 * function rpcImpl(method, requestData, callback) {
 *     if (protobuf.util.lcFirst(method.name) !== "myMethod") // compatible with static code
 *         throw Error("no such method");
 *     asynchronouslyObtainAResponse(requestData, function(err, responseData) {
 *         callback(err, responseData);
 *     });
 * }
 */

/**
 * Node-style callback as used by {@link RPCImpl}.
 * @typedef RPCImplCallback
 * @type {function}
 * @param {Error|null} error Error, if any, otherwise `null`
 * @param {Uint8Array|null} [response] Response data or `null` to signal end of stream, if there hasn't been an error
 * @returns {undefined}
 */

rpc.Service = require("./rpc/service");

},{"./rpc/service":721}],721:[function(require,module,exports){
"use strict";
module.exports = Service;

var util = require("../util/minimal");

// Extends EventEmitter
(Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;

/**
 * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.
 *
 * Differs from {@link RPCImplCallback} in that it is an actual callback of a service method which may not return `response = null`.
 * @typedef rpc.ServiceMethodCallback
 * @template TRes extends Message<TRes>
 * @type {function}
 * @param {Error|null} error Error, if any
 * @param {TRes} [response] Response message
 * @returns {undefined}
 */

/**
 * A service method part of a {@link rpc.Service} as created by {@link Service.create}.
 * @typedef rpc.ServiceMethod
 * @template TReq extends Message<TReq>
 * @template TRes extends Message<TRes>
 * @type {function}
 * @param {TReq|Properties<TReq>} request Request message or plain object
 * @param {rpc.ServiceMethodCallback<TRes>} [callback] Node-style callback called with the error, if any, and the response message
 * @returns {Promise<Message<TRes>>} Promise if `callback` has been omitted, otherwise `undefined`
 */

/**
 * Constructs a new RPC service instance.
 * @classdesc An RPC service as returned by {@link Service#create}.
 * @exports rpc.Service
 * @extends util.EventEmitter
 * @constructor
 * @param {RPCImpl} rpcImpl RPC implementation
 * @param {boolean} [requestDelimited=false] Whether requests are length-delimited
 * @param {boolean} [responseDelimited=false] Whether responses are length-delimited
 */
function Service(rpcImpl, requestDelimited, responseDelimited) {

    if (typeof rpcImpl !== "function")
        throw TypeError("rpcImpl must be a function");

    util.EventEmitter.call(this);

    /**
     * RPC implementation. Becomes `null` once the service is ended.
     * @type {RPCImpl|null}
     */
    this.rpcImpl = rpcImpl;

    /**
     * Whether requests are length-delimited.
     * @type {boolean}
     */
    this.requestDelimited = Boolean(requestDelimited);

    /**
     * Whether responses are length-delimited.
     * @type {boolean}
     */
    this.responseDelimited = Boolean(responseDelimited);
}

/**
 * Calls a service method through {@link rpc.Service#rpcImpl|rpcImpl}.
 * @param {Method|rpc.ServiceMethod<TReq,TRes>} method Reflected or static method
 * @param {Constructor<TReq>} requestCtor Request constructor
 * @param {Constructor<TRes>} responseCtor Response constructor
 * @param {TReq|Properties<TReq>} request Request message or plain object
 * @param {rpc.ServiceMethodCallback<TRes>} callback Service callback
 * @returns {undefined}
 * @template TReq extends Message<TReq>
 * @template TRes extends Message<TRes>
 */
Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {

    if (!request)
        throw TypeError("request must be specified");

    var self = this;
    if (!callback)
        return util.asPromise(rpcCall, self, method, requestCtor, responseCtor, request);

    if (!self.rpcImpl) {
        setTimeout(function() { callback(Error("already ended")); }, 0);
        return undefined;
    }

    try {
        return self.rpcImpl(
            method,
            requestCtor[self.requestDelimited ? "encodeDelimited" : "encode"](request).finish(),
            function rpcCallback(err, response) {

                if (err) {
                    self.emit("error", err, method);
                    return callback(err);
                }

                if (response === null) {
                    self.end(/* endedByRPC */ true);
                    return undefined;
                }

                if (!(response instanceof responseCtor)) {
                    try {
                        response = responseCtor[self.responseDelimited ? "decodeDelimited" : "decode"](response);
                    } catch (err) {
                        self.emit("error", err, method);
                        return callback(err);
                    }
                }

                self.emit("data", response, method);
                return callback(null, response);
            }
        );
    } catch (err) {
        self.emit("error", err, method);
        setTimeout(function() { callback(err); }, 0);
        return undefined;
    }
};

/**
 * Ends this service and emits the `end` event.
 * @param {boolean} [endedByRPC=false] Whether the service has been ended by the RPC implementation.
 * @returns {rpc.Service} `this`
 */
Service.prototype.end = function end(endedByRPC) {
    if (this.rpcImpl) {
        if (!endedByRPC) // signal end to rpcImpl
            this.rpcImpl(null, null, null);
        this.rpcImpl = null;
        this.emit("end").off();
    }
    return this;
};

},{"../util/minimal":723}],722:[function(require,module,exports){
"use strict";
module.exports = LongBits;

var util = require("../util/minimal");

/**
 * Constructs new long bits.
 * @classdesc Helper class for working with the low and high bits of a 64 bit value.
 * @memberof util
 * @constructor
 * @param {number} lo Low 32 bits, unsigned
 * @param {number} hi High 32 bits, unsigned
 */
function LongBits(lo, hi) {

    // note that the casts below are theoretically unnecessary as of today, but older statically
    // generated converter code might still call the ctor with signed 32bits. kept for compat.

    /**
     * Low bits.
     * @type {number}
     */
    this.lo = lo >>> 0;

    /**
     * High bits.
     * @type {number}
     */
    this.hi = hi >>> 0;
}

/**
 * Zero bits.
 * @memberof util.LongBits
 * @type {util.LongBits}
 */
var zero = LongBits.zero = new LongBits(0, 0);

zero.toNumber = function() { return 0; };
zero.zzEncode = zero.zzDecode = function() { return this; };
zero.length = function() { return 1; };

/**
 * Zero hash.
 * @memberof util.LongBits
 * @type {string}
 */
var zeroHash = LongBits.zeroHash = "\0\0\0\0\0\0\0\0";

/**
 * Constructs new long bits from the specified number.
 * @param {number} value Value
 * @returns {util.LongBits} Instance
 */
LongBits.fromNumber = function fromNumber(value) {
    if (value === 0)
        return zero;
    var sign = value < 0;
    if (sign)
        value = -value;
    var lo = value >>> 0,
        hi = (value - lo) / 4294967296 >>> 0;
    if (sign) {
        hi = ~hi >>> 0;
        lo = ~lo >>> 0;
        if (++lo > 4294967295) {
            lo = 0;
            if (++hi > 4294967295)
                hi = 0;
        }
    }
    return new LongBits(lo, hi);
};

/**
 * Constructs new long bits from a number, long or string.
 * @param {Long|number|string} value Value
 * @returns {util.LongBits} Instance
 */
LongBits.from = function from(value) {
    if (typeof value === "number")
        return LongBits.fromNumber(value);
    if (util.isString(value)) {
        /* istanbul ignore else */
        if (util.Long)
            value = util.Long.fromString(value);
        else
            return LongBits.fromNumber(parseInt(value, 10));
    }
    return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
};

/**
 * Converts this long bits to a possibly unsafe JavaScript number.
 * @param {boolean} [unsigned=false] Whether unsigned or not
 * @returns {number} Possibly unsafe number
 */
LongBits.prototype.toNumber = function toNumber(unsigned) {
    if (!unsigned && this.hi >>> 31) {
        var lo = ~this.lo + 1 >>> 0,
            hi = ~this.hi     >>> 0;
        if (!lo)
            hi = hi + 1 >>> 0;
        return -(lo + hi * 4294967296);
    }
    return this.lo + this.hi * 4294967296;
};

/**
 * Converts this long bits to a long.
 * @param {boolean} [unsigned=false] Whether unsigned or not
 * @returns {Long} Long
 */
LongBits.prototype.toLong = function toLong(unsigned) {
    return util.Long
        ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned))
        /* istanbul ignore next */
        : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };
};

var charCodeAt = String.prototype.charCodeAt;

/**
 * Constructs new long bits from the specified 8 characters long hash.
 * @param {string} hash Hash
 * @returns {util.LongBits} Bits
 */
LongBits.fromHash = function fromHash(hash) {
    if (hash === zeroHash)
        return zero;
    return new LongBits(
        ( charCodeAt.call(hash, 0)
        | charCodeAt.call(hash, 1) << 8
        | charCodeAt.call(hash, 2) << 16
        | charCodeAt.call(hash, 3) << 24) >>> 0
    ,
        ( charCodeAt.call(hash, 4)
        | charCodeAt.call(hash, 5) << 8
        | charCodeAt.call(hash, 6) << 16
        | charCodeAt.call(hash, 7) << 24) >>> 0
    );
};

/**
 * Converts this long bits to a 8 characters long hash.
 * @returns {string} Hash
 */
LongBits.prototype.toHash = function toHash() {
    return String.fromCharCode(
        this.lo        & 255,
        this.lo >>> 8  & 255,
        this.lo >>> 16 & 255,
        this.lo >>> 24      ,
        this.hi        & 255,
        this.hi >>> 8  & 255,
        this.hi >>> 16 & 255,
        this.hi >>> 24
    );
};

/**
 * Zig-zag encodes this long bits.
 * @returns {util.LongBits} `this`
 */
LongBits.prototype.zzEncode = function zzEncode() {
    var mask =   this.hi >> 31;
    this.hi  = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
    this.lo  = ( this.lo << 1                   ^ mask) >>> 0;
    return this;
};

/**
 * Zig-zag decodes this long bits.
 * @returns {util.LongBits} `this`
 */
LongBits.prototype.zzDecode = function zzDecode() {
    var mask = -(this.lo & 1);
    this.lo  = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
    this.hi  = ( this.hi >>> 1                  ^ mask) >>> 0;
    return this;
};

/**
 * Calculates the length of this longbits when encoded as a varint.
 * @returns {number} Length
 */
LongBits.prototype.length = function length() {
    var part0 =  this.lo,
        part1 = (this.lo >>> 28 | this.hi << 4) >>> 0,
        part2 =  this.hi >>> 24;
    return part2 === 0
         ? part1 === 0
           ? part0 < 16384
             ? part0 < 128 ? 1 : 2
             : part0 < 2097152 ? 3 : 4
           : part1 < 16384
             ? part1 < 128 ? 5 : 6
             : part1 < 2097152 ? 7 : 8
         : part2 < 128 ? 9 : 10;
};

},{"../util/minimal":723}],723:[function(require,module,exports){
(function (global){(function (){
"use strict";
var util = exports;

// used to return a Promise where callback is omitted
util.asPromise = require("@protobufjs/aspromise");

// converts to / from base64 encoded strings
util.base64 = require("@protobufjs/base64");

// base class of rpc.Service
util.EventEmitter = require("@protobufjs/eventemitter");

// float handling accross browsers
util.float = require("@protobufjs/float");

// requires modules optionally and hides the call from bundlers
util.inquire = require("@protobufjs/inquire");

// converts to / from utf8 encoded strings
util.utf8 = require("@protobufjs/utf8");

// provides a node-like buffer pool in the browser
util.pool = require("@protobufjs/pool");

// utility to work with the low and high bits of a 64 bit value
util.LongBits = require("./longbits");

/**
 * Whether running within node or not.
 * @memberof util
 * @type {boolean}
 */
util.isNode = Boolean(typeof global !== "undefined"
                   && global
                   && global.process
                   && global.process.versions
                   && global.process.versions.node);

/**
 * Global object reference.
 * @memberof util
 * @type {Object}
 */
util.global = util.isNode && global
           || typeof window !== "undefined" && window
           || typeof self   !== "undefined" && self
           || this; // eslint-disable-line no-invalid-this

/**
 * An immuable empty array.
 * @memberof util
 * @type {Array.<*>}
 * @const
 */
util.emptyArray = Object.freeze ? Object.freeze([]) : /* istanbul ignore next */ []; // used on prototypes

/**
 * An immutable empty object.
 * @type {Object}
 * @const
 */
util.emptyObject = Object.freeze ? Object.freeze({}) : /* istanbul ignore next */ {}; // used on prototypes

/**
 * Tests if the specified value is an integer.
 * @function
 * @param {*} value Value to test
 * @returns {boolean} `true` if the value is an integer
 */
util.isInteger = Number.isInteger || /* istanbul ignore next */ function isInteger(value) {
    return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
};

/**
 * Tests if the specified value is a string.
 * @param {*} value Value to test
 * @returns {boolean} `true` if the value is a string
 */
util.isString = function isString(value) {
    return typeof value === "string" || value instanceof String;
};

/**
 * Tests if the specified value is a non-null object.
 * @param {*} value Value to test
 * @returns {boolean} `true` if the value is a non-null object
 */
util.isObject = function isObject(value) {
    return value && typeof value === "object";
};

/**
 * Checks if a property on a message is considered to be present.
 * This is an alias of {@link util.isSet}.
 * @function
 * @param {Object} obj Plain object or message instance
 * @param {string} prop Property name
 * @returns {boolean} `true` if considered to be present, otherwise `false`
 */
util.isset =

/**
 * Checks if a property on a message is considered to be present.
 * @param {Object} obj Plain object or message instance
 * @param {string} prop Property name
 * @returns {boolean} `true` if considered to be present, otherwise `false`
 */
util.isSet = function isSet(obj, prop) {
    var value = obj[prop];
    if (value != null && obj.hasOwnProperty(prop)) // eslint-disable-line eqeqeq, no-prototype-builtins
        return typeof value !== "object" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;
    return false;
};

/**
 * Any compatible Buffer instance.
 * This is a minimal stand-alone definition of a Buffer instance. The actual type is that exported by node's typings.
 * @interface Buffer
 * @extends Uint8Array
 */

/**
 * Node's Buffer class if available.
 * @type {Constructor<Buffer>}
 */
util.Buffer = (function() {
    try {
        var Buffer = util.inquire("buffer").Buffer;
        // refuse to use non-node buffers if not explicitly assigned (perf reasons):
        return Buffer.prototype.utf8Write ? Buffer : /* istanbul ignore next */ null;
    } catch (e) {
        /* istanbul ignore next */
        return null;
    }
})();

// Internal alias of or polyfull for Buffer.from.
util._Buffer_from = null;

// Internal alias of or polyfill for Buffer.allocUnsafe.
util._Buffer_allocUnsafe = null;

/**
 * Creates a new buffer of whatever type supported by the environment.
 * @param {number|number[]} [sizeOrArray=0] Buffer size or number array
 * @returns {Uint8Array|Buffer} Buffer
 */
util.newBuffer = function newBuffer(sizeOrArray) {
    /* istanbul ignore next */
    return typeof sizeOrArray === "number"
        ? util.Buffer
            ? util._Buffer_allocUnsafe(sizeOrArray)
            : new util.Array(sizeOrArray)
        : util.Buffer
            ? util._Buffer_from(sizeOrArray)
            : typeof Uint8Array === "undefined"
                ? sizeOrArray
                : new Uint8Array(sizeOrArray);
};

/**
 * Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.
 * @type {Constructor<Uint8Array>}
 */
util.Array = typeof Uint8Array !== "undefined" ? Uint8Array /* istanbul ignore next */ : Array;

/**
 * Any compatible Long instance.
 * This is a minimal stand-alone definition of a Long instance. The actual type is that exported by long.js.
 * @interface Long
 * @property {number} low Low bits
 * @property {number} high High bits
 * @property {boolean} unsigned Whether unsigned or not
 */

/**
 * Long.js's Long class if available.
 * @type {Constructor<Long>}
 */
util.Long = /* istanbul ignore next */ util.global.dcodeIO && /* istanbul ignore next */ util.global.dcodeIO.Long
         || /* istanbul ignore next */ util.global.Long
         || util.inquire("long");

/**
 * Regular expression used to verify 2 bit (`bool`) map keys.
 * @type {RegExp}
 * @const
 */
util.key2Re = /^true|false|0|1$/;

/**
 * Regular expression used to verify 32 bit (`int32` etc.) map keys.
 * @type {RegExp}
 * @const
 */
util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;

/**
 * Regular expression used to verify 64 bit (`int64` etc.) map keys.
 * @type {RegExp}
 * @const
 */
util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;

/**
 * Converts a number or long to an 8 characters long hash string.
 * @param {Long|number} value Value to convert
 * @returns {string} Hash
 */
util.longToHash = function longToHash(value) {
    return value
        ? util.LongBits.from(value).toHash()
        : util.LongBits.zeroHash;
};

/**
 * Converts an 8 characters long hash string to a long or number.
 * @param {string} hash Hash
 * @param {boolean} [unsigned=false] Whether unsigned or not
 * @returns {Long|number} Original value
 */
util.longFromHash = function longFromHash(hash, unsigned) {
    var bits = util.LongBits.fromHash(hash);
    if (util.Long)
        return util.Long.fromBits(bits.lo, bits.hi, unsigned);
    return bits.toNumber(Boolean(unsigned));
};

/**
 * Merges the properties of the source object into the destination object.
 * @memberof util
 * @param {Object.<string,*>} dst Destination object
 * @param {Object.<string,*>} src Source object
 * @param {boolean} [ifNotSet=false] Merges only if the key is not already set
 * @returns {Object.<string,*>} Destination object
 */
function merge(dst, src, ifNotSet) { // used by converters
    for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)
        if (dst[keys[i]] === undefined || !ifNotSet)
            dst[keys[i]] = src[keys[i]];
    return dst;
}

util.merge = merge;

/**
 * Converts the first character of a string to lower case.
 * @param {string} str String to convert
 * @returns {string} Converted string
 */
util.lcFirst = function lcFirst(str) {
    return str.charAt(0).toLowerCase() + str.substring(1);
};

/**
 * Creates a custom error constructor.
 * @memberof util
 * @param {string} name Error name
 * @returns {Constructor<Error>} Custom error constructor
 */
function newError(name) {

    function CustomError(message, properties) {

        if (!(this instanceof CustomError))
            return new CustomError(message, properties);

        // Error.call(this, message);
        // ^ just returns a new error instance because the ctor can be called as a function

        Object.defineProperty(this, "message", { get: function() { return message; } });

        /* istanbul ignore next */
        if (Error.captureStackTrace) // node
            Error.captureStackTrace(this, CustomError);
        else
            Object.defineProperty(this, "stack", { value: new Error().stack || "" });

        if (properties)
            merge(this, properties);
    }

    (CustomError.prototype = Object.create(Error.prototype)).constructor = CustomError;

    Object.defineProperty(CustomError.prototype, "name", { get: function() { return name; } });

    CustomError.prototype.toString = function toString() {
        return this.name + ": " + this.message;
    };

    return CustomError;
}

util.newError = newError;

/**
 * Constructs a new protocol error.
 * @classdesc Error subclass indicating a protocol specifc error.
 * @memberof util
 * @extends Error
 * @template T extends Message<T>
 * @constructor
 * @param {string} message Error message
 * @param {Object.<string,*>} [properties] Additional properties
 * @example
 * try {
 *     MyMessage.decode(someBuffer); // throws if required fields are missing
 * } catch (e) {
 *     if (e instanceof ProtocolError && e.instance)
 *         console.log("decoded so far: " + JSON.stringify(e.instance));
 * }
 */
util.ProtocolError = newError("ProtocolError");

/**
 * So far decoded message instance.
 * @name util.ProtocolError#instance
 * @type {Message<T>}
 */

/**
 * A OneOf getter as returned by {@link util.oneOfGetter}.
 * @typedef OneOfGetter
 * @type {function}
 * @returns {string|undefined} Set field name, if any
 */

/**
 * Builds a getter for a oneof's present field name.
 * @param {string[]} fieldNames Field names
 * @returns {OneOfGetter} Unbound getter
 */
util.oneOfGetter = function getOneOf(fieldNames) {
    var fieldMap = {};
    for (var i = 0; i < fieldNames.length; ++i)
        fieldMap[fieldNames[i]] = 1;

    /**
     * @returns {string|undefined} Set field name, if any
     * @this Object
     * @ignore
     */
    return function() { // eslint-disable-line consistent-return
        for (var keys = Object.keys(this), i = keys.length - 1; i > -1; --i)
            if (fieldMap[keys[i]] === 1 && this[keys[i]] !== undefined && this[keys[i]] !== null)
                return keys[i];
    };
};

/**
 * A OneOf setter as returned by {@link util.oneOfSetter}.
 * @typedef OneOfSetter
 * @type {function}
 * @param {string|undefined} value Field name
 * @returns {undefined}
 */

/**
 * Builds a setter for a oneof's present field name.
 * @param {string[]} fieldNames Field names
 * @returns {OneOfSetter} Unbound setter
 */
util.oneOfSetter = function setOneOf(fieldNames) {

    /**
     * @param {string} name Field name
     * @returns {undefined}
     * @this Object
     * @ignore
     */
    return function(name) {
        for (var i = 0; i < fieldNames.length; ++i)
            if (fieldNames[i] !== name)
                delete this[fieldNames[i]];
    };
};

/**
 * Default conversion options used for {@link Message#toJSON} implementations.
 *
 * These options are close to proto3's JSON mapping with the exception that internal types like Any are handled just like messages. More precisely:
 *
 * - Longs become strings
 * - Enums become string keys
 * - Bytes become base64 encoded strings
 * - (Sub-)Messages become plain objects
 * - Maps become plain objects with all string keys
 * - Repeated fields become arrays
 * - NaN and Infinity for float and double fields become strings
 *
 * @type {IConversionOptions}
 * @see https://developers.google.com/protocol-buffers/docs/proto3?hl=en#json
 */
util.toJSONOptions = {
    longs: String,
    enums: String,
    bytes: String,
    json: true
};

// Sets up buffer utility according to the environment (called in index-minimal)
util._configure = function() {
    var Buffer = util.Buffer;
    /* istanbul ignore if */
    if (!Buffer) {
        util._Buffer_from = util._Buffer_allocUnsafe = null;
        return;
    }
    // because node 4.x buffers are incompatible & immutable
    // see: https://github.com/dcodeIO/protobuf.js/pull/665
    util._Buffer_from = Buffer.from !== Uint8Array.from && Buffer.from ||
        /* istanbul ignore next */
        function Buffer_from(value, encoding) {
            return new Buffer(value, encoding);
        };
    util._Buffer_allocUnsafe = Buffer.allocUnsafe ||
        /* istanbul ignore next */
        function Buffer_allocUnsafe(size) {
            return new Buffer(size);
        };
};

}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{"./longbits":722,"@protobufjs/aspromise":66,"@protobufjs/base64":67,"@protobufjs/eventemitter":68,"@protobufjs/float":69,"@protobufjs/inquire":70,"@protobufjs/pool":71,"@protobufjs/utf8":72}],724:[function(require,module,exports){
"use strict";
module.exports = Writer;

var util      = require("./util/minimal");

var BufferWriter; // cyclic

var LongBits  = util.LongBits,
    base64    = util.base64,
    utf8      = util.utf8;

/**
 * Constructs a new writer operation instance.
 * @classdesc Scheduled writer operation.
 * @constructor
 * @param {function(*, Uint8Array, number)} fn Function to call
 * @param {number} len Value byte length
 * @param {*} val Value to write
 * @ignore
 */
function Op(fn, len, val) {

    /**
     * Function to call.
     * @type {function(Uint8Array, number, *)}
     */
    this.fn = fn;

    /**
     * Value byte length.
     * @type {number}
     */
    this.len = len;

    /**
     * Next operation.
     * @type {Writer.Op|undefined}
     */
    this.next = undefined;

    /**
     * Value to write.
     * @type {*}
     */
    this.val = val; // type varies
}

/* istanbul ignore next */
function noop() {} // eslint-disable-line no-empty-function

/**
 * Constructs a new writer state instance.
 * @classdesc Copied writer state.
 * @memberof Writer
 * @constructor
 * @param {Writer} writer Writer to copy state from
 * @ignore
 */
function State(writer) {

    /**
     * Current head.
     * @type {Writer.Op}
     */
    this.head = writer.head;

    /**
     * Current tail.
     * @type {Writer.Op}
     */
    this.tail = writer.tail;

    /**
     * Current buffer length.
     * @type {number}
     */
    this.len = writer.len;

    /**
     * Next state.
     * @type {State|null}
     */
    this.next = writer.states;
}

/**
 * Constructs a new writer instance.
 * @classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.
 * @constructor
 */
function Writer() {

    /**
     * Current length.
     * @type {number}
     */
    this.len = 0;

    /**
     * Operations head.
     * @type {Object}
     */
    this.head = new Op(noop, 0, 0);

    /**
     * Operations tail
     * @type {Object}
     */
    this.tail = this.head;

    /**
     * Linked forked states.
     * @type {Object|null}
     */
    this.states = null;

    // When a value is written, the writer calculates its byte length and puts it into a linked
    // list of operations to perform when finish() is called. This both allows us to allocate
    // buffers of the exact required size and reduces the amount of work we have to do compared
    // to first calculating over objects and then encoding over objects. In our case, the encoding
    // part is just a linked list walk calling operations with already prepared values.
}

var create = function create() {
    return util.Buffer
        ? function create_buffer_setup() {
            return (Writer.create = function create_buffer() {
                return new BufferWriter();
            })();
        }
        /* istanbul ignore next */
        : function create_array() {
            return new Writer();
        };
};

/**
 * Creates a new writer.
 * @function
 * @returns {BufferWriter|Writer} A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}
 */
Writer.create = create();

/**
 * Allocates a buffer of the specified size.
 * @param {number} size Buffer size
 * @returns {Uint8Array} Buffer
 */
Writer.alloc = function alloc(size) {
    return new util.Array(size);
};

// Use Uint8Array buffer pool in the browser, just like node does with buffers
/* istanbul ignore else */
if (util.Array !== Array)
    Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);

/**
 * Pushes a new operation to the queue.
 * @param {function(Uint8Array, number, *)} fn Function to call
 * @param {number} len Value byte length
 * @param {number} val Value to write
 * @returns {Writer} `this`
 * @private
 */
Writer.prototype._push = function push(fn, len, val) {
    this.tail = this.tail.next = new Op(fn, len, val);
    this.len += len;
    return this;
};

function writeByte(val, buf, pos) {
    buf[pos] = val & 255;
}

function writeVarint32(val, buf, pos) {
    while (val > 127) {
        buf[pos++] = val & 127 | 128;
        val >>>= 7;
    }
    buf[pos] = val;
}

/**
 * Constructs a new varint writer operation instance.
 * @classdesc Scheduled varint writer operation.
 * @extends Op
 * @constructor
 * @param {number} len Value byte length
 * @param {number} val Value to write
 * @ignore
 */
function VarintOp(len, val) {
    this.len = len;
    this.next = undefined;
    this.val = val;
}

VarintOp.prototype = Object.create(Op.prototype);
VarintOp.prototype.fn = writeVarint32;

/**
 * Writes an unsigned 32 bit value as a varint.
 * @param {number} value Value to write
 * @returns {Writer} `this`
 */
Writer.prototype.uint32 = function write_uint32(value) {
    // here, the call to this.push has been inlined and a varint specific Op subclass is used.
    // uint32 is by far the most frequently used operation and benefits significantly from this.
    this.len += (this.tail = this.tail.next = new VarintOp(
        (value = value >>> 0)
                < 128       ? 1
        : value < 16384     ? 2
        : value < 2097152   ? 3
        : value < 268435456 ? 4
        :                     5,
    value)).len;
    return this;
};

/**
 * Writes a signed 32 bit value as a varint.
 * @function
 * @param {number} value Value to write
 * @returns {Writer} `this`
 */
Writer.prototype.int32 = function write_int32(value) {
    return value < 0
        ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) // 10 bytes per spec
        : this.uint32(value);
};

/**
 * Writes a 32 bit value as a varint, zig-zag encoded.
 * @param {number} value Value to write
 * @returns {Writer} `this`
 */
Writer.prototype.sint32 = function write_sint32(value) {
    return this.uint32((value << 1 ^ value >> 31) >>> 0);
};

function writeVarint64(val, buf, pos) {
    while (val.hi) {
        buf[pos++] = val.lo & 127 | 128;
        val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
        val.hi >>>= 7;
    }
    while (val.lo > 127) {
        buf[pos++] = val.lo & 127 | 128;
        val.lo = val.lo >>> 7;
    }
    buf[pos++] = val.lo;
}

/**
 * Writes an unsigned 64 bit value as a varint.
 * @param {Long|number|string} value Value to write
 * @returns {Writer} `this`
 * @throws {TypeError} If `value` is a string and no long library is present.
 */
Writer.prototype.uint64 = function write_uint64(value) {
    var bits = LongBits.from(value);
    return this._push(writeVarint64, bits.length(), bits);
};

/**
 * Writes a signed 64 bit value as a varint.
 * @function
 * @param {Long|number|string} value Value to write
 * @returns {Writer} `this`
 * @throws {TypeError} If `value` is a string and no long library is present.
 */
Writer.prototype.int64 = Writer.prototype.uint64;

/**
 * Writes a signed 64 bit value as a varint, zig-zag encoded.
 * @param {Long|number|string} value Value to write
 * @returns {Writer} `this`
 * @throws {TypeError} If `value` is a string and no long library is present.
 */
Writer.prototype.sint64 = function write_sint64(value) {
    var bits = LongBits.from(value).zzEncode();
    return this._push(writeVarint64, bits.length(), bits);
};

/**
 * Writes a boolish value as a varint.
 * @param {boolean} value Value to write
 * @returns {Writer} `this`
 */
Writer.prototype.bool = function write_bool(value) {
    return this._push(writeByte, 1, value ? 1 : 0);
};

function writeFixed32(val, buf, pos) {
    buf[pos    ] =  val         & 255;
    buf[pos + 1] =  val >>> 8   & 255;
    buf[pos + 2] =  val >>> 16  & 255;
    buf[pos + 3] =  val >>> 24;
}

/**
 * Writes an unsigned 32 bit value as fixed 32 bits.
 * @param {number} value Value to write
 * @returns {Writer} `this`
 */
Writer.prototype.fixed32 = function write_fixed32(value) {
    return this._push(writeFixed32, 4, value >>> 0);
};

/**
 * Writes a signed 32 bit value as fixed 32 bits.
 * @function
 * @param {number} value Value to write
 * @returns {Writer} `this`
 */
Writer.prototype.sfixed32 = Writer.prototype.fixed32;

/**
 * Writes an unsigned 64 bit value as fixed 64 bits.
 * @param {Long|number|string} value Value to write
 * @returns {Writer} `this`
 * @throws {TypeError} If `value` is a string and no long library is present.
 */
Writer.prototype.fixed64 = function write_fixed64(value) {
    var bits = LongBits.from(value);
    return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
};

/**
 * Writes a signed 64 bit value as fixed 64 bits.
 * @function
 * @param {Long|number|string} value Value to write
 * @returns {Writer} `this`
 * @throws {TypeError} If `value` is a string and no long library is present.
 */
Writer.prototype.sfixed64 = Writer.prototype.fixed64;

/**
 * Writes a float (32 bit).
 * @function
 * @param {number} value Value to write
 * @returns {Writer} `this`
 */
Writer.prototype.float = function write_float(value) {
    return this._push(util.float.writeFloatLE, 4, value);
};

/**
 * Writes a double (64 bit float).
 * @function
 * @param {number} value Value to write
 * @returns {Writer} `this`
 */
Writer.prototype.double = function write_double(value) {
    return this._push(util.float.writeDoubleLE, 8, value);
};

var writeBytes = util.Array.prototype.set
    ? function writeBytes_set(val, buf, pos) {
        buf.set(val, pos); // also works for plain array values
    }
    /* istanbul ignore next */
    : function writeBytes_for(val, buf, pos) {
        for (var i = 0; i < val.length; ++i)
            buf[pos + i] = val[i];
    };

/**
 * Writes a sequence of bytes.
 * @param {Uint8Array|string} value Buffer or base64 encoded string to write
 * @returns {Writer} `this`
 */
Writer.prototype.bytes = function write_bytes(value) {
    var len = value.length >>> 0;
    if (!len)
        return this._push(writeByte, 1, 0);
    if (util.isString(value)) {
        var buf = Writer.alloc(len = base64.length(value));
        base64.decode(value, buf, 0);
        value = buf;
    }
    return this.uint32(len)._push(writeBytes, len, value);
};

/**
 * Writes a string.
 * @param {string} value Value to write
 * @returns {Writer} `this`
 */
Writer.prototype.string = function write_string(value) {
    var len = utf8.length(value);
    return len
        ? this.uint32(len)._push(utf8.write, len, value)
        : this._push(writeByte, 1, 0);
};

/**
 * Forks this writer's state by pushing it to a stack.
 * Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.
 * @returns {Writer} `this`
 */
Writer.prototype.fork = function fork() {
    this.states = new State(this);
    this.head = this.tail = new Op(noop, 0, 0);
    this.len = 0;
    return this;
};

/**
 * Resets this instance to the last state.
 * @returns {Writer} `this`
 */
Writer.prototype.reset = function reset() {
    if (this.states) {
        this.head   = this.states.head;
        this.tail   = this.states.tail;
        this.len    = this.states.len;
        this.states = this.states.next;
    } else {
        this.head = this.tail = new Op(noop, 0, 0);
        this.len  = 0;
    }
    return this;
};

/**
 * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.
 * @returns {Writer} `this`
 */
Writer.prototype.ldelim = function ldelim() {
    var head = this.head,
        tail = this.tail,
        len  = this.len;
    this.reset().uint32(len);
    if (len) {
        this.tail.next = head.next; // skip noop
        this.tail = tail;
        this.len += len;
    }
    return this;
};

/**
 * Finishes the write operation.
 * @returns {Uint8Array} Finished buffer
 */
Writer.prototype.finish = function finish() {
    var head = this.head.next, // skip noop
        buf  = this.constructor.alloc(this.len),
        pos  = 0;
    while (head) {
        head.fn(head.val, buf, pos);
        pos += head.len;
        head = head.next;
    }
    // this.head = this.tail = null;
    return buf;
};

Writer._configure = function(BufferWriter_) {
    BufferWriter = BufferWriter_;
    Writer.create = create();
    BufferWriter._configure();
};

},{"./util/minimal":723}],725:[function(require,module,exports){
"use strict";
module.exports = BufferWriter;

// extends Writer
var Writer = require("./writer");
(BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;

var util = require("./util/minimal");

/**
 * Constructs a new buffer writer instance.
 * @classdesc Wire format writer using node buffers.
 * @extends Writer
 * @constructor
 */
function BufferWriter() {
    Writer.call(this);
}

BufferWriter._configure = function () {
    /**
     * Allocates a buffer of the specified size.
     * @function
     * @param {number} size Buffer size
     * @returns {Buffer} Buffer
     */
    BufferWriter.alloc = util._Buffer_allocUnsafe;

    BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === "set"
        ? function writeBytesBuffer_set(val, buf, pos) {
          buf.set(val, pos); // faster than copy (requires node >= 4 where Buffers extend Uint8Array and set is properly inherited)
          // also works for plain array values
        }
        /* istanbul ignore next */
        : function writeBytesBuffer_copy(val, buf, pos) {
          if (val.copy) // Buffer values
            val.copy(buf, pos, 0, val.length);
          else for (var i = 0; i < val.length;) // plain array values
            buf[pos++] = val[i++];
        };
};


/**
 * @override
 */
BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
    if (util.isString(value))
        value = util._Buffer_from(value, "base64");
    var len = value.length >>> 0;
    this.uint32(len);
    if (len)
        this._push(BufferWriter.writeBytesBuffer, len, value);
    return this;
};

function writeStringBuffer(val, buf, pos) {
    if (val.length < 40) // plain js is faster for short strings (probably due to redundant assertions)
        util.utf8.write(val, buf, pos);
    else if (buf.utf8Write)
        buf.utf8Write(val, pos);
    else
        buf.write(val, pos);
}

/**
 * @override
 */
BufferWriter.prototype.string = function write_string_buffer(value) {
    var len = util.Buffer.byteLength(value);
    this.uint32(len);
    if (len)
        this._push(writeStringBuffer, len, value);
    return this;
};


/**
 * Finishes the write operation.
 * @name BufferWriter#finish
 * @function
 * @returns {Buffer} Finished buffer
 */

BufferWriter._configure();

},{"./util/minimal":723,"./writer":724}],726:[function(require,module,exports){
(function (global){(function (){
/*! https://mths.be/punycode v1.4.1 by @mathias */
;(function(root) {

	/** Detect free variables */
	var freeExports = typeof exports == 'object' && exports &&
		!exports.nodeType && exports;
	var freeModule = typeof module == 'object' && module &&
		!module.nodeType && module;
	var freeGlobal = typeof global == 'object' && global;
	if (
		freeGlobal.global === freeGlobal ||
		freeGlobal.window === freeGlobal ||
		freeGlobal.self === freeGlobal
	) {
		root = freeGlobal;
	}

	/**
	 * The `punycode` object.
	 * @name punycode
	 * @type Object
	 */
	var punycode,

	/** Highest positive signed 32-bit float value */
	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1

	/** Bootstring parameters */
	base = 36,
	tMin = 1,
	tMax = 26,
	skew = 38,
	damp = 700,
	initialBias = 72,
	initialN = 128, // 0x80
	delimiter = '-', // '\x2D'

	/** Regular expressions */
	regexPunycode = /^xn--/,
	regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
	regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators

	/** Error messages */
	errors = {
		'overflow': 'Overflow: input needs wider integers to process',
		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
		'invalid-input': 'Invalid input'
	},

	/** Convenience shortcuts */
	baseMinusTMin = base - tMin,
	floor = Math.floor,
	stringFromCharCode = String.fromCharCode,

	/** Temporary variable */
	key;

	/*--------------------------------------------------------------------------*/

	/**
	 * A generic error utility function.
	 * @private
	 * @param {String} type The error type.
	 * @returns {Error} Throws a `RangeError` with the applicable error message.
	 */
	function error(type) {
		throw new RangeError(errors[type]);
	}

	/**
	 * A generic `Array#map` utility function.
	 * @private
	 * @param {Array} array The array to iterate over.
	 * @param {Function} callback The function that gets called for every array
	 * item.
	 * @returns {Array} A new array of values returned by the callback function.
	 */
	function map(array, fn) {
		var length = array.length;
		var result = [];
		while (length--) {
			result[length] = fn(array[length]);
		}
		return result;
	}

	/**
	 * A simple `Array#map`-like wrapper to work with domain name strings or email
	 * addresses.
	 * @private
	 * @param {String} domain The domain name or email address.
	 * @param {Function} callback The function that gets called for every
	 * character.
	 * @returns {Array} A new string of characters returned by the callback
	 * function.
	 */
	function mapDomain(string, fn) {
		var parts = string.split('@');
		var result = '';
		if (parts.length > 1) {
			// In email addresses, only the domain name should be punycoded. Leave
			// the local part (i.e. everything up to `@`) intact.
			result = parts[0] + '@';
			string = parts[1];
		}
		// Avoid `split(regex)` for IE8 compatibility. See #17.
		string = string.replace(regexSeparators, '\x2E');
		var labels = string.split('.');
		var encoded = map(labels, fn).join('.');
		return result + encoded;
	}

	/**
	 * Creates an array containing the numeric code points of each Unicode
	 * character in the string. While JavaScript uses UCS-2 internally,
	 * this function will convert a pair of surrogate halves (each of which
	 * UCS-2 exposes as separate characters) into a single code point,
	 * matching UTF-16.
	 * @see `punycode.ucs2.encode`
	 * @see <https://mathiasbynens.be/notes/javascript-encoding>
	 * @memberOf punycode.ucs2
	 * @name decode
	 * @param {String} string The Unicode input string (UCS-2).
	 * @returns {Array} The new array of code points.
	 */
	function ucs2decode(string) {
		var output = [],
		    counter = 0,
		    length = string.length,
		    value,
		    extra;
		while (counter < length) {
			value = string.charCodeAt(counter++);
			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
				// high surrogate, and there is a next character
				extra = string.charCodeAt(counter++);
				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
				} else {
					// unmatched surrogate; only append this code unit, in case the next
					// code unit is the high surrogate of a surrogate pair
					output.push(value);
					counter--;
				}
			} else {
				output.push(value);
			}
		}
		return output;
	}

	/**
	 * Creates a string based on an array of numeric code points.
	 * @see `punycode.ucs2.decode`
	 * @memberOf punycode.ucs2
	 * @name encode
	 * @param {Array} codePoints The array of numeric code points.
	 * @returns {String} The new Unicode string (UCS-2).
	 */
	function ucs2encode(array) {
		return map(array, function(value) {
			var output = '';
			if (value > 0xFFFF) {
				value -= 0x10000;
				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
				value = 0xDC00 | value & 0x3FF;
			}
			output += stringFromCharCode(value);
			return output;
		}).join('');
	}

	/**
	 * Converts a basic code point into a digit/integer.
	 * @see `digitToBasic()`
	 * @private
	 * @param {Number} codePoint The basic numeric code point value.
	 * @returns {Number} The numeric value of a basic code point (for use in
	 * representing integers) in the range `0` to `base - 1`, or `base` if
	 * the code point does not represent a value.
	 */
	function basicToDigit(codePoint) {
		if (codePoint - 48 < 10) {
			return codePoint - 22;
		}
		if (codePoint - 65 < 26) {
			return codePoint - 65;
		}
		if (codePoint - 97 < 26) {
			return codePoint - 97;
		}
		return base;
	}

	/**
	 * Converts a digit/integer into a basic code point.
	 * @see `basicToDigit()`
	 * @private
	 * @param {Number} digit The numeric value of a basic code point.
	 * @returns {Number} The basic code point whose value (when used for
	 * representing integers) is `digit`, which needs to be in the range
	 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
	 * used; else, the lowercase form is used. The behavior is undefined
	 * if `flag` is non-zero and `digit` has no uppercase form.
	 */
	function digitToBasic(digit, flag) {
		//  0..25 map to ASCII a..z or A..Z
		// 26..35 map to ASCII 0..9
		return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
	}

	/**
	 * Bias adaptation function as per section 3.4 of RFC 3492.
	 * https://tools.ietf.org/html/rfc3492#section-3.4
	 * @private
	 */
	function adapt(delta, numPoints, firstTime) {
		var k = 0;
		delta = firstTime ? floor(delta / damp) : delta >> 1;
		delta += floor(delta / numPoints);
		for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
			delta = floor(delta / baseMinusTMin);
		}
		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
	}

	/**
	 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
	 * symbols.
	 * @memberOf punycode
	 * @param {String} input The Punycode string of ASCII-only symbols.
	 * @returns {String} The resulting string of Unicode symbols.
	 */
	function decode(input) {
		// Don't use UCS-2
		var output = [],
		    inputLength = input.length,
		    out,
		    i = 0,
		    n = initialN,
		    bias = initialBias,
		    basic,
		    j,
		    index,
		    oldi,
		    w,
		    k,
		    digit,
		    t,
		    /** Cached calculation results */
		    baseMinusT;

		// Handle the basic code points: let `basic` be the number of input code
		// points before the last delimiter, or `0` if there is none, then copy
		// the first basic code points to the output.

		basic = input.lastIndexOf(delimiter);
		if (basic < 0) {
			basic = 0;
		}

		for (j = 0; j < basic; ++j) {
			// if it's not a basic code point
			if (input.charCodeAt(j) >= 0x80) {
				error('not-basic');
			}
			output.push(input.charCodeAt(j));
		}

		// Main decoding loop: start just after the last delimiter if any basic code
		// points were copied; start at the beginning otherwise.

		for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {

			// `index` is the index of the next character to be consumed.
			// Decode a generalized variable-length integer into `delta`,
			// which gets added to `i`. The overflow checking is easier
			// if we increase `i` as we go, then subtract off its starting
			// value at the end to obtain `delta`.
			for (oldi = i, w = 1, k = base; /* no condition */; k += base) {

				if (index >= inputLength) {
					error('invalid-input');
				}

				digit = basicToDigit(input.charCodeAt(index++));

				if (digit >= base || digit > floor((maxInt - i) / w)) {
					error('overflow');
				}

				i += digit * w;
				t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);

				if (digit < t) {
					break;
				}

				baseMinusT = base - t;
				if (w > floor(maxInt / baseMinusT)) {
					error('overflow');
				}

				w *= baseMinusT;

			}

			out = output.length + 1;
			bias = adapt(i - oldi, out, oldi == 0);

			// `i` was supposed to wrap around from `out` to `0`,
			// incrementing `n` each time, so we'll fix that now:
			if (floor(i / out) > maxInt - n) {
				error('overflow');
			}

			n += floor(i / out);
			i %= out;

			// Insert `n` at position `i` of the output
			output.splice(i++, 0, n);

		}

		return ucs2encode(output);
	}

	/**
	 * Converts a string of Unicode symbols (e.g. a domain name label) to a
	 * Punycode string of ASCII-only symbols.
	 * @memberOf punycode
	 * @param {String} input The string of Unicode symbols.
	 * @returns {String} The resulting Punycode string of ASCII-only symbols.
	 */
	function encode(input) {
		var n,
		    delta,
		    handledCPCount,
		    basicLength,
		    bias,
		    j,
		    m,
		    q,
		    k,
		    t,
		    currentValue,
		    output = [],
		    /** `inputLength` will hold the number of code points in `input`. */
		    inputLength,
		    /** Cached calculation results */
		    handledCPCountPlusOne,
		    baseMinusT,
		    qMinusT;

		// Convert the input in UCS-2 to Unicode
		input = ucs2decode(input);

		// Cache the length
		inputLength = input.length;

		// Initialize the state
		n = initialN;
		delta = 0;
		bias = initialBias;

		// Handle the basic code points
		for (j = 0; j < inputLength; ++j) {
			currentValue = input[j];
			if (currentValue < 0x80) {
				output.push(stringFromCharCode(currentValue));
			}
		}

		handledCPCount = basicLength = output.length;

		// `handledCPCount` is the number of code points that have been handled;
		// `basicLength` is the number of basic code points.

		// Finish the basic string - if it is not empty - with a delimiter
		if (basicLength) {
			output.push(delimiter);
		}

		// Main encoding loop:
		while (handledCPCount < inputLength) {

			// All non-basic code points < n have been handled already. Find the next
			// larger one:
			for (m = maxInt, j = 0; j < inputLength; ++j) {
				currentValue = input[j];
				if (currentValue >= n && currentValue < m) {
					m = currentValue;
				}
			}

			// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
			// but guard against overflow
			handledCPCountPlusOne = handledCPCount + 1;
			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
				error('overflow');
			}

			delta += (m - n) * handledCPCountPlusOne;
			n = m;

			for (j = 0; j < inputLength; ++j) {
				currentValue = input[j];

				if (currentValue < n && ++delta > maxInt) {
					error('overflow');
				}

				if (currentValue == n) {
					// Represent delta as a generalized variable-length integer
					for (q = delta, k = base; /* no condition */; k += base) {
						t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
						if (q < t) {
							break;
						}
						qMinusT = q - t;
						baseMinusT = base - t;
						output.push(
							stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
						);
						q = floor(qMinusT / baseMinusT);
					}

					output.push(stringFromCharCode(digitToBasic(q, 0)));
					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
					delta = 0;
					++handledCPCount;
				}
			}

			++delta;
			++n;

		}
		return output.join('');
	}

	/**
	 * Converts a Punycode string representing a domain name or an email address
	 * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
	 * it doesn't matter if you call it on a string that has already been
	 * converted to Unicode.
	 * @memberOf punycode
	 * @param {String} input The Punycoded domain name or email address to
	 * convert to Unicode.
	 * @returns {String} The Unicode representation of the given Punycode
	 * string.
	 */
	function toUnicode(input) {
		return mapDomain(input, function(string) {
			return regexPunycode.test(string)
				? decode(string.slice(4).toLowerCase())
				: string;
		});
	}

	/**
	 * Converts a Unicode string representing a domain name or an email address to
	 * Punycode. Only the non-ASCII parts of the domain name will be converted,
	 * i.e. it doesn't matter if you call it with a domain that's already in
	 * ASCII.
	 * @memberOf punycode
	 * @param {String} input The domain name or email address to convert, as a
	 * Unicode string.
	 * @returns {String} The Punycode representation of the given domain name or
	 * email address.
	 */
	function toASCII(input) {
		return mapDomain(input, function(string) {
			return regexNonASCII.test(string)
				? 'xn--' + encode(string)
				: string;
		});
	}

	/*--------------------------------------------------------------------------*/

	/** Define the public API */
	punycode = {
		/**
		 * A string representing the current Punycode.js version number.
		 * @memberOf punycode
		 * @type String
		 */
		'version': '1.4.1',
		/**
		 * An object of methods to convert from JavaScript's internal character
		 * representation (UCS-2) to Unicode code points, and back.
		 * @see <https://mathiasbynens.be/notes/javascript-encoding>
		 * @memberOf punycode
		 * @type Object
		 */
		'ucs2': {
			'decode': ucs2decode,
			'encode': ucs2encode
		},
		'decode': decode,
		'encode': encode,
		'toASCII': toASCII,
		'toUnicode': toUnicode
	};

	/** Expose `punycode` */
	// Some AMD build optimizers, like r.js, check for specific condition patterns
	// like the following:
	if (
		typeof define == 'function' &&
		typeof define.amd == 'object' &&
		define.amd
	) {
		define('punycode', function() {
			return punycode;
		});
	} else if (freeExports && freeModule) {
		if (module.exports == freeExports) {
			// in Node.js, io.js, or RingoJS v0.8.0+
			freeModule.exports = punycode;
		} else {
			// in Narwhal or RingoJS v0.7.0-
			for (key in punycode) {
				punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
			}
		}
	} else {
		// in Rhino or a web browser
		root.punycode = punycode;
	}

}(this));

}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{}],727:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

'use strict';

// If obj.hasOwnProperty has been overridden, then calling
// obj.hasOwnProperty(prop) will break.
// See: https://github.com/joyent/node/issues/1707
function hasOwnProperty(obj, prop) {
  return Object.prototype.hasOwnProperty.call(obj, prop);
}

module.exports = function(qs, sep, eq, options) {
  sep = sep || '&';
  eq = eq || '=';
  var obj = {};

  if (typeof qs !== 'string' || qs.length === 0) {
    return obj;
  }

  var regexp = /\+/g;
  qs = qs.split(sep);

  var maxKeys = 1000;
  if (options && typeof options.maxKeys === 'number') {
    maxKeys = options.maxKeys;
  }

  var len = qs.length;
  // maxKeys <= 0 means that we should not limit keys count
  if (maxKeys > 0 && len > maxKeys) {
    len = maxKeys;
  }

  for (var i = 0; i < len; ++i) {
    var x = qs[i].replace(regexp, '%20'),
        idx = x.indexOf(eq),
        kstr, vstr, k, v;

    if (idx >= 0) {
      kstr = x.substr(0, idx);
      vstr = x.substr(idx + 1);
    } else {
      kstr = x;
      vstr = '';
    }

    k = decodeURIComponent(kstr);
    v = decodeURIComponent(vstr);

    if (!hasOwnProperty(obj, k)) {
      obj[k] = v;
    } else if (isArray(obj[k])) {
      obj[k].push(v);
    } else {
      obj[k] = [obj[k], v];
    }
  }

  return obj;
};

var isArray = Array.isArray || function (xs) {
  return Object.prototype.toString.call(xs) === '[object Array]';
};

},{}],728:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

'use strict';

var stringifyPrimitive = function(v) {
  switch (typeof v) {
    case 'string':
      return v;

    case 'boolean':
      return v ? 'true' : 'false';

    case 'number':
      return isFinite(v) ? v : '';

    default:
      return '';
  }
};

module.exports = function(obj, sep, eq, name) {
  sep = sep || '&';
  eq = eq || '=';
  if (obj === null) {
    obj = undefined;
  }

  if (typeof obj === 'object') {
    return map(objectKeys(obj), function(k) {
      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
      if (isArray(obj[k])) {
        return map(obj[k], function(v) {
          return ks + encodeURIComponent(stringifyPrimitive(v));
        }).join(sep);
      } else {
        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
      }
    }).join(sep);

  }

  if (!name) return '';
  return encodeURIComponent(stringifyPrimitive(name)) + eq +
         encodeURIComponent(stringifyPrimitive(obj));
};

var isArray = Array.isArray || function (xs) {
  return Object.prototype.toString.call(xs) === '[object Array]';
};

function map (xs, f) {
  if (xs.map) return xs.map(f);
  var res = [];
  for (var i = 0; i < xs.length; i++) {
    res.push(f(xs[i], i));
  }
  return res;
}

var objectKeys = Object.keys || function (obj) {
  var res = [];
  for (var key in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
  }
  return res;
};

},{}],729:[function(require,module,exports){
'use strict';

exports.decode = exports.parse = require('./decode');
exports.encode = exports.stringify = require('./encode');

},{"./decode":727,"./encode":728}],730:[function(require,module,exports){
/**
 * Copyright (c) 2014-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

var runtime = (function (exports) {
  "use strict";

  var Op = Object.prototype;
  var hasOwn = Op.hasOwnProperty;
  var undefined; // More compressible than void 0.
  var $Symbol = typeof Symbol === "function" ? Symbol : {};
  var iteratorSymbol = $Symbol.iterator || "@@iterator";
  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";

  function define(obj, key, value) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
    return obj[key];
  }
  try {
    // IE 8 has a broken Object.defineProperty that only works on DOM objects.
    define({}, "");
  } catch (err) {
    define = function(obj, key, value) {
      return obj[key] = value;
    };
  }

  function wrap(innerFn, outerFn, self, tryLocsList) {
    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
    var generator = Object.create(protoGenerator.prototype);
    var context = new Context(tryLocsList || []);

    // The ._invoke method unifies the implementations of the .next,
    // .throw, and .return methods.
    generator._invoke = makeInvokeMethod(innerFn, self, context);

    return generator;
  }
  exports.wrap = wrap;

  // Try/catch helper to minimize deoptimizations. Returns a completion
  // record like context.tryEntries[i].completion. This interface could
  // have been (and was previously) designed to take a closure to be
  // invoked without arguments, but in all the cases we care about we
  // already have an existing method we want to call, so there's no need
  // to create a new function object. We can even get away with assuming
  // the method takes exactly one argument, since that happens to be true
  // in every case, so we don't have to touch the arguments object. The
  // only additional allocation required is the completion record, which
  // has a stable shape and so hopefully should be cheap to allocate.
  function tryCatch(fn, obj, arg) {
    try {
      return { type: "normal", arg: fn.call(obj, arg) };
    } catch (err) {
      return { type: "throw", arg: err };
    }
  }

  var GenStateSuspendedStart = "suspendedStart";
  var GenStateSuspendedYield = "suspendedYield";
  var GenStateExecuting = "executing";
  var GenStateCompleted = "completed";

  // Returning this object from the innerFn has the same effect as
  // breaking out of the dispatch switch statement.
  var ContinueSentinel = {};

  // Dummy constructor functions that we use as the .constructor and
  // .constructor.prototype properties for functions that return Generator
  // objects. For full spec compliance, you may wish to configure your
  // minifier not to mangle the names of these two functions.
  function Generator() {}
  function GeneratorFunction() {}
  function GeneratorFunctionPrototype() {}

  // This is a polyfill for %IteratorPrototype% for environments that
  // don't natively support it.
  var IteratorPrototype = {};
  define(IteratorPrototype, iteratorSymbol, function () {
    return this;
  });

  var getProto = Object.getPrototypeOf;
  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
  if (NativeIteratorPrototype &&
      NativeIteratorPrototype !== Op &&
      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
    // This environment has a native %IteratorPrototype%; use it instead
    // of the polyfill.
    IteratorPrototype = NativeIteratorPrototype;
  }

  var Gp = GeneratorFunctionPrototype.prototype =
    Generator.prototype = Object.create(IteratorPrototype);
  GeneratorFunction.prototype = GeneratorFunctionPrototype;
  define(Gp, "constructor", GeneratorFunctionPrototype);
  define(GeneratorFunctionPrototype, "constructor", GeneratorFunction);
  GeneratorFunction.displayName = define(
    GeneratorFunctionPrototype,
    toStringTagSymbol,
    "GeneratorFunction"
  );

  // Helper for defining the .next, .throw, and .return methods of the
  // Iterator interface in terms of a single ._invoke method.
  function defineIteratorMethods(prototype) {
    ["next", "throw", "return"].forEach(function(method) {
      define(prototype, method, function(arg) {
        return this._invoke(method, arg);
      });
    });
  }

  exports.isGeneratorFunction = function(genFun) {
    var ctor = typeof genFun === "function" && genFun.constructor;
    return ctor
      ? ctor === GeneratorFunction ||
        // For the native GeneratorFunction constructor, the best we can
        // do is to check its .name property.
        (ctor.displayName || ctor.name) === "GeneratorFunction"
      : false;
  };

  exports.mark = function(genFun) {
    if (Object.setPrototypeOf) {
      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
    } else {
      genFun.__proto__ = GeneratorFunctionPrototype;
      define(genFun, toStringTagSymbol, "GeneratorFunction");
    }
    genFun.prototype = Object.create(Gp);
    return genFun;
  };

  // Within the body of any async function, `await x` is transformed to
  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
  // `hasOwn.call(value, "__await")` to determine if the yielded value is
  // meant to be awaited.
  exports.awrap = function(arg) {
    return { __await: arg };
  };

  function AsyncIterator(generator, PromiseImpl) {
    function invoke(method, arg, resolve, reject) {
      var record = tryCatch(generator[method], generator, arg);
      if (record.type === "throw") {
        reject(record.arg);
      } else {
        var result = record.arg;
        var value = result.value;
        if (value &&
            typeof value === "object" &&
            hasOwn.call(value, "__await")) {
          return PromiseImpl.resolve(value.__await).then(function(value) {
            invoke("next", value, resolve, reject);
          }, function(err) {
            invoke("throw", err, resolve, reject);
          });
        }

        return PromiseImpl.resolve(value).then(function(unwrapped) {
          // When a yielded Promise is resolved, its final value becomes
          // the .value of the Promise<{value,done}> result for the
          // current iteration.
          result.value = unwrapped;
          resolve(result);
        }, function(error) {
          // If a rejected Promise was yielded, throw the rejection back
          // into the async generator function so it can be handled there.
          return invoke("throw", error, resolve, reject);
        });
      }
    }

    var previousPromise;

    function enqueue(method, arg) {
      function callInvokeWithMethodAndArg() {
        return new PromiseImpl(function(resolve, reject) {
          invoke(method, arg, resolve, reject);
        });
      }

      return previousPromise =
        // If enqueue has been called before, then we want to wait until
        // all previous Promises have been resolved before calling invoke,
        // so that results are always delivered in the correct order. If
        // enqueue has not been called before, then it is important to
        // call invoke immediately, without waiting on a callback to fire,
        // so that the async generator function has the opportunity to do
        // any necessary setup in a predictable way. This predictability
        // is why the Promise constructor synchronously invokes its
        // executor callback, and why async functions synchronously
        // execute code before the first await. Since we implement simple
        // async functions in terms of async generators, it is especially
        // important to get this right, even though it requires care.
        previousPromise ? previousPromise.then(
          callInvokeWithMethodAndArg,
          // Avoid propagating failures to Promises returned by later
          // invocations of the iterator.
          callInvokeWithMethodAndArg
        ) : callInvokeWithMethodAndArg();
    }

    // Define the unified helper method that is used to implement .next,
    // .throw, and .return (see defineIteratorMethods).
    this._invoke = enqueue;
  }

  defineIteratorMethods(AsyncIterator.prototype);
  define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
    return this;
  });
  exports.AsyncIterator = AsyncIterator;

  // Note that simple async functions are implemented on top of
  // AsyncIterator objects; they just return a Promise for the value of
  // the final result produced by the iterator.
  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
    if (PromiseImpl === void 0) PromiseImpl = Promise;

    var iter = new AsyncIterator(
      wrap(innerFn, outerFn, self, tryLocsList),
      PromiseImpl
    );

    return exports.isGeneratorFunction(outerFn)
      ? iter // If outerFn is a generator, return the full iterator.
      : iter.next().then(function(result) {
          return result.done ? result.value : iter.next();
        });
  };

  function makeInvokeMethod(innerFn, self, context) {
    var state = GenStateSuspendedStart;

    return function invoke(method, arg) {
      if (state === GenStateExecuting) {
        throw new Error("Generator is already running");
      }

      if (state === GenStateCompleted) {
        if (method === "throw") {
          throw arg;
        }

        // Be forgiving, per 25.3.3.3.3 of the spec:
        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
        return doneResult();
      }

      context.method = method;
      context.arg = arg;

      while (true) {
        var delegate = context.delegate;
        if (delegate) {
          var delegateResult = maybeInvokeDelegate(delegate, context);
          if (delegateResult) {
            if (delegateResult === ContinueSentinel) continue;
            return delegateResult;
          }
        }

        if (context.method === "next") {
          // Setting context._sent for legacy support of Babel's
          // function.sent implementation.
          context.sent = context._sent = context.arg;

        } else if (context.method === "throw") {
          if (state === GenStateSuspendedStart) {
            state = GenStateCompleted;
            throw context.arg;
          }

          context.dispatchException(context.arg);

        } else if (context.method === "return") {
          context.abrupt("return", context.arg);
        }

        state = GenStateExecuting;

        var record = tryCatch(innerFn, self, context);
        if (record.type === "normal") {
          // If an exception is thrown from innerFn, we leave state ===
          // GenStateExecuting and loop back for another invocation.
          state = context.done
            ? GenStateCompleted
            : GenStateSuspendedYield;

          if (record.arg === ContinueSentinel) {
            continue;
          }

          return {
            value: record.arg,
            done: context.done
          };

        } else if (record.type === "throw") {
          state = GenStateCompleted;
          // Dispatch the exception by looping back around to the
          // context.dispatchException(context.arg) call above.
          context.method = "throw";
          context.arg = record.arg;
        }
      }
    };
  }

  // Call delegate.iterator[context.method](context.arg) and handle the
  // result, either by returning a { value, done } result from the
  // delegate iterator, or by modifying context.method and context.arg,
  // setting context.delegate to null, and returning the ContinueSentinel.
  function maybeInvokeDelegate(delegate, context) {
    var method = delegate.iterator[context.method];
    if (method === undefined) {
      // A .throw or .return when the delegate iterator has no .throw
      // method always terminates the yield* loop.
      context.delegate = null;

      if (context.method === "throw") {
        // Note: ["return"] must be used for ES3 parsing compatibility.
        if (delegate.iterator["return"]) {
          // If the delegate iterator has a return method, give it a
          // chance to clean up.
          context.method = "return";
          context.arg = undefined;
          maybeInvokeDelegate(delegate, context);

          if (context.method === "throw") {
            // If maybeInvokeDelegate(context) changed context.method from
            // "return" to "throw", let that override the TypeError below.
            return ContinueSentinel;
          }
        }

        context.method = "throw";
        context.arg = new TypeError(
          "The iterator does not provide a 'throw' method");
      }

      return ContinueSentinel;
    }

    var record = tryCatch(method, delegate.iterator, context.arg);

    if (record.type === "throw") {
      context.method = "throw";
      context.arg = record.arg;
      context.delegate = null;
      return ContinueSentinel;
    }

    var info = record.arg;

    if (! info) {
      context.method = "throw";
      context.arg = new TypeError("iterator result is not an object");
      context.delegate = null;
      return ContinueSentinel;
    }

    if (info.done) {
      // Assign the result of the finished delegate to the temporary
      // variable specified by delegate.resultName (see delegateYield).
      context[delegate.resultName] = info.value;

      // Resume execution at the desired location (see delegateYield).
      context.next = delegate.nextLoc;

      // If context.method was "throw" but the delegate handled the
      // exception, let the outer generator proceed normally. If
      // context.method was "next", forget context.arg since it has been
      // "consumed" by the delegate iterator. If context.method was
      // "return", allow the original .return call to continue in the
      // outer generator.
      if (context.method !== "return") {
        context.method = "next";
        context.arg = undefined;
      }

    } else {
      // Re-yield the result returned by the delegate method.
      return info;
    }

    // The delegate iterator is finished, so forget it and continue with
    // the outer generator.
    context.delegate = null;
    return ContinueSentinel;
  }

  // Define Generator.prototype.{next,throw,return} in terms of the
  // unified ._invoke helper method.
  defineIteratorMethods(Gp);

  define(Gp, toStringTagSymbol, "Generator");

  // A Generator should always return itself as the iterator object when the
  // @@iterator function is called on it. Some browsers' implementations of the
  // iterator prototype chain incorrectly implement this, causing the Generator
  // object to not be returned from this call. This ensures that doesn't happen.
  // See https://github.com/facebook/regenerator/issues/274 for more details.
  define(Gp, iteratorSymbol, function() {
    return this;
  });

  define(Gp, "toString", function() {
    return "[object Generator]";
  });

  function pushTryEntry(locs) {
    var entry = { tryLoc: locs[0] };

    if (1 in locs) {
      entry.catchLoc = locs[1];
    }

    if (2 in locs) {
      entry.finallyLoc = locs[2];
      entry.afterLoc = locs[3];
    }

    this.tryEntries.push(entry);
  }

  function resetTryEntry(entry) {
    var record = entry.completion || {};
    record.type = "normal";
    delete record.arg;
    entry.completion = record;
  }

  function Context(tryLocsList) {
    // The root entry object (effectively a try statement without a catch
    // or a finally block) gives us a place to store values thrown from
    // locations where there is no enclosing try statement.
    this.tryEntries = [{ tryLoc: "root" }];
    tryLocsList.forEach(pushTryEntry, this);
    this.reset(true);
  }

  exports.keys = function(object) {
    var keys = [];
    for (var key in object) {
      keys.push(key);
    }
    keys.reverse();

    // Rather than returning an object with a next method, we keep
    // things simple and return the next function itself.
    return function next() {
      while (keys.length) {
        var key = keys.pop();
        if (key in object) {
          next.value = key;
          next.done = false;
          return next;
        }
      }

      // To avoid creating an additional object, we just hang the .value
      // and .done properties off the next function object itself. This
      // also ensures that the minifier will not anonymize the function.
      next.done = true;
      return next;
    };
  };

  function values(iterable) {
    if (iterable) {
      var iteratorMethod = iterable[iteratorSymbol];
      if (iteratorMethod) {
        return iteratorMethod.call(iterable);
      }

      if (typeof iterable.next === "function") {
        return iterable;
      }

      if (!isNaN(iterable.length)) {
        var i = -1, next = function next() {
          while (++i < iterable.length) {
            if (hasOwn.call(iterable, i)) {
              next.value = iterable[i];
              next.done = false;
              return next;
            }
          }

          next.value = undefined;
          next.done = true;

          return next;
        };

        return next.next = next;
      }
    }

    // Return an iterator with no values.
    return { next: doneResult };
  }
  exports.values = values;

  function doneResult() {
    return { value: undefined, done: true };
  }

  Context.prototype = {
    constructor: Context,

    reset: function(skipTempReset) {
      this.prev = 0;
      this.next = 0;
      // Resetting context._sent for legacy support of Babel's
      // function.sent implementation.
      this.sent = this._sent = undefined;
      this.done = false;
      this.delegate = null;

      this.method = "next";
      this.arg = undefined;

      this.tryEntries.forEach(resetTryEntry);

      if (!skipTempReset) {
        for (var name in this) {
          // Not sure about the optimal order of these conditions:
          if (name.charAt(0) === "t" &&
              hasOwn.call(this, name) &&
              !isNaN(+name.slice(1))) {
            this[name] = undefined;
          }
        }
      }
    },

    stop: function() {
      this.done = true;

      var rootEntry = this.tryEntries[0];
      var rootRecord = rootEntry.completion;
      if (rootRecord.type === "throw") {
        throw rootRecord.arg;
      }

      return this.rval;
    },

    dispatchException: function(exception) {
      if (this.done) {
        throw exception;
      }

      var context = this;
      function handle(loc, caught) {
        record.type = "throw";
        record.arg = exception;
        context.next = loc;

        if (caught) {
          // If the dispatched exception was caught by a catch block,
          // then let that catch block handle the exception normally.
          context.method = "next";
          context.arg = undefined;
        }

        return !! caught;
      }

      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        var record = entry.completion;

        if (entry.tryLoc === "root") {
          // Exception thrown outside of any try block that could handle
          // it, so set the completion value of the entire function to
          // throw the exception.
          return handle("end");
        }

        if (entry.tryLoc <= this.prev) {
          var hasCatch = hasOwn.call(entry, "catchLoc");
          var hasFinally = hasOwn.call(entry, "finallyLoc");

          if (hasCatch && hasFinally) {
            if (this.prev < entry.catchLoc) {
              return handle(entry.catchLoc, true);
            } else if (this.prev < entry.finallyLoc) {
              return handle(entry.finallyLoc);
            }

          } else if (hasCatch) {
            if (this.prev < entry.catchLoc) {
              return handle(entry.catchLoc, true);
            }

          } else if (hasFinally) {
            if (this.prev < entry.finallyLoc) {
              return handle(entry.finallyLoc);
            }

          } else {
            throw new Error("try statement without catch or finally");
          }
        }
      }
    },

    abrupt: function(type, arg) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.tryLoc <= this.prev &&
            hasOwn.call(entry, "finallyLoc") &&
            this.prev < entry.finallyLoc) {
          var finallyEntry = entry;
          break;
        }
      }

      if (finallyEntry &&
          (type === "break" ||
           type === "continue") &&
          finallyEntry.tryLoc <= arg &&
          arg <= finallyEntry.finallyLoc) {
        // Ignore the finally entry if control is not jumping to a
        // location outside the try/catch block.
        finallyEntry = null;
      }

      var record = finallyEntry ? finallyEntry.completion : {};
      record.type = type;
      record.arg = arg;

      if (finallyEntry) {
        this.method = "next";
        this.next = finallyEntry.finallyLoc;
        return ContinueSentinel;
      }

      return this.complete(record);
    },

    complete: function(record, afterLoc) {
      if (record.type === "throw") {
        throw record.arg;
      }

      if (record.type === "break" ||
          record.type === "continue") {
        this.next = record.arg;
      } else if (record.type === "return") {
        this.rval = this.arg = record.arg;
        this.method = "return";
        this.next = "end";
      } else if (record.type === "normal" && afterLoc) {
        this.next = afterLoc;
      }

      return ContinueSentinel;
    },

    finish: function(finallyLoc) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.finallyLoc === finallyLoc) {
          this.complete(entry.completion, entry.afterLoc);
          resetTryEntry(entry);
          return ContinueSentinel;
        }
      }
    },

    "catch": function(tryLoc) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.tryLoc === tryLoc) {
          var record = entry.completion;
          if (record.type === "throw") {
            var thrown = record.arg;
            resetTryEntry(entry);
          }
          return thrown;
        }
      }

      // The context.catch method must only be called with a location
      // argument that corresponds to a known catch block.
      throw new Error("illegal catch attempt");
    },

    delegateYield: function(iterable, resultName, nextLoc) {
      this.delegate = {
        iterator: values(iterable),
        resultName: resultName,
        nextLoc: nextLoc
      };

      if (this.method === "next") {
        // Deliberately forget the last sent value so that we don't
        // accidentally pass it on to the delegate.
        this.arg = undefined;
      }

      return ContinueSentinel;
    }
  };

  // Regardless of whether this script is executing as a CommonJS module
  // or not, return the runtime object so that we can declare the variable
  // regeneratorRuntime in the outer scope, which allows this module to be
  // injected easily by `bin/regenerator --include-runtime script.js`.
  return exports;

}(
  // If this script is executing as a CommonJS module, use module.exports
  // as the regeneratorRuntime namespace. Otherwise create a new empty
  // object. Either way, the resulting object will be used to initialize
  // the regeneratorRuntime variable at the top of this file.
  typeof module === "object" ? module.exports : {}
));

try {
  regeneratorRuntime = runtime;
} catch (accidentalStrictMode) {
  // This module should not be running in strict mode, so the above
  // assignment should always work unless something is misconfigured. Just
  // in case runtime.js accidentally runs in strict mode, in modern engines
  // we can explicitly access globalThis. In older engines we can escape
  // strict mode using a global Function call. This could conceivably fail
  // if a Content Security Policy forbids using Function, but in that case
  // the proper solution is to fix the accidental strict mode problem. If
  // you've misconfigured your bundler to force strict mode and applied a
  // CSP to forbid Function, and you're not willing to fix either of those
  // problems, please detail your unique predicament in a GitHub issue.
  if (typeof globalThis === "object") {
    globalThis.regeneratorRuntime = runtime;
  } else {
    Function("r", "regeneratorRuntime = r")(runtime);
  }
}

},{}],731:[function(require,module,exports){
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
/* eslint-disable node/no-deprecated-api */
var buffer = require('buffer')
var Buffer = buffer.Buffer

// alternative to using Object.keys for old browsers
function copyProps (src, dst) {
  for (var key in src) {
    dst[key] = src[key]
  }
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
  module.exports = buffer
} else {
  // Copy properties from require('buffer')
  copyProps(buffer, exports)
  exports.Buffer = SafeBuffer
}

function SafeBuffer (arg, encodingOrOffset, length) {
  return Buffer(arg, encodingOrOffset, length)
}

SafeBuffer.prototype = Object.create(Buffer.prototype)

// Copy static methods from Buffer
copyProps(Buffer, SafeBuffer)

SafeBuffer.from = function (arg, encodingOrOffset, length) {
  if (typeof arg === 'number') {
    throw new TypeError('Argument must not be a number')
  }
  return Buffer(arg, encodingOrOffset, length)
}

SafeBuffer.alloc = function (size, fill, encoding) {
  if (typeof size !== 'number') {
    throw new TypeError('Argument must be a number')
  }
  var buf = Buffer(size)
  if (fill !== undefined) {
    if (typeof encoding === 'string') {
      buf.fill(fill, encoding)
    } else {
      buf.fill(fill)
    }
  } else {
    buf.fill(0)
  }
  return buf
}

SafeBuffer.allocUnsafe = function (size) {
  if (typeof size !== 'number') {
    throw new TypeError('Argument must be a number')
  }
  return Buffer(size)
}

SafeBuffer.allocUnsafeSlow = function (size) {
  if (typeof size !== 'number') {
    throw new TypeError('Argument must be a number')
  }
  return buffer.SlowBuffer(size)
}

},{"buffer":81}],732:[function(require,module,exports){
(function (global){(function (){
var ClientRequest = require('./lib/request')
var response = require('./lib/response')
var extend = require('xtend')
var statusCodes = require('builtin-status-codes')
var url = require('url')

var http = exports

http.request = function (opts, cb) {
	if (typeof opts === 'string')
		opts = url.parse(opts)
	else
		opts = extend(opts)

	// Normally, the page is loaded from http or https, so not specifying a protocol
	// will result in a (valid) protocol-relative url. However, this won't work if
	// the protocol is something else, like 'file:'
	var defaultProtocol = global.location.protocol.search(/^https?:$/) === -1 ? 'http:' : ''

	var protocol = opts.protocol || defaultProtocol
	var host = opts.hostname || opts.host
	var port = opts.port
	var path = opts.path || '/'

	// Necessary for IPv6 addresses
	if (host && host.indexOf(':') !== -1)
		host = '[' + host + ']'

	// This may be a relative url. The browser should always be able to interpret it correctly.
	opts.url = (host ? (protocol + '//' + host) : '') + (port ? ':' + port : '') + path
	opts.method = (opts.method || 'GET').toUpperCase()
	opts.headers = opts.headers || {}

	// Also valid opts.auth, opts.mode

	var req = new ClientRequest(opts)
	if (cb)
		req.on('response', cb)
	return req
}

http.get = function get (opts, cb) {
	var req = http.request(opts, cb)
	req.end()
	return req
}

http.ClientRequest = ClientRequest
http.IncomingMessage = response.IncomingMessage

http.Agent = function () {}
http.Agent.defaultMaxSockets = 4

http.globalAgent = new http.Agent()

http.STATUS_CODES = statusCodes

http.METHODS = [
	'CHECKOUT',
	'CONNECT',
	'COPY',
	'DELETE',
	'GET',
	'HEAD',
	'LOCK',
	'M-SEARCH',
	'MERGE',
	'MKACTIVITY',
	'MKCOL',
	'MOVE',
	'NOTIFY',
	'OPTIONS',
	'PATCH',
	'POST',
	'PROPFIND',
	'PROPPATCH',
	'PURGE',
	'PUT',
	'REPORT',
	'SEARCH',
	'SUBSCRIBE',
	'TRACE',
	'UNLOCK',
	'UNSUBSCRIBE'
]
}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{"./lib/request":734,"./lib/response":735,"builtin-status-codes":82,"url":753,"xtend":756}],733:[function(require,module,exports){
(function (global){(function (){
exports.fetch = isFunction(global.fetch) && isFunction(global.ReadableStream)

exports.writableStream = isFunction(global.WritableStream)

exports.abortController = isFunction(global.AbortController)

// The xhr request to example.com may violate some restrictive CSP configurations,
// so if we're running in a browser that supports `fetch`, avoid calling getXHR()
// and assume support for certain features below.
var xhr
function getXHR () {
	// Cache the xhr value
	if (xhr !== undefined) return xhr

	if (global.XMLHttpRequest) {
		xhr = new global.XMLHttpRequest()
		// If XDomainRequest is available (ie only, where xhr might not work
		// cross domain), use the page location. Otherwise use example.com
		// Note: this doesn't actually make an http request.
		try {
			xhr.open('GET', global.XDomainRequest ? '/' : 'https://example.com')
		} catch(e) {
			xhr = null
		}
	} else {
		// Service workers don't have XHR
		xhr = null
	}
	return xhr
}

function checkTypeSupport (type) {
	var xhr = getXHR()
	if (!xhr) return false
	try {
		xhr.responseType = type
		return xhr.responseType === type
	} catch (e) {}
	return false
}

// If fetch is supported, then arraybuffer will be supported too. Skip calling
// checkTypeSupport(), since that calls getXHR().
exports.arraybuffer = exports.fetch || checkTypeSupport('arraybuffer')

// These next two tests unavoidably show warnings in Chrome. Since fetch will always
// be used if it's available, just return false for these to avoid the warnings.
exports.msstream = !exports.fetch && checkTypeSupport('ms-stream')
exports.mozchunkedarraybuffer = !exports.fetch && checkTypeSupport('moz-chunked-arraybuffer')

// If fetch is supported, then overrideMimeType will be supported too. Skip calling
// getXHR().
exports.overrideMimeType = exports.fetch || (getXHR() ? isFunction(getXHR().overrideMimeType) : false)

function isFunction (value) {
	return typeof value === 'function'
}

xhr = null // Help gc

}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{}],734:[function(require,module,exports){
(function (process,global,Buffer){(function (){
var capability = require('./capability')
var inherits = require('inherits')
var response = require('./response')
var stream = require('readable-stream')

var IncomingMessage = response.IncomingMessage
var rStates = response.readyStates

function decideMode (preferBinary, useFetch) {
	if (capability.fetch && useFetch) {
		return 'fetch'
	} else if (capability.mozchunkedarraybuffer) {
		return 'moz-chunked-arraybuffer'
	} else if (capability.msstream) {
		return 'ms-stream'
	} else if (capability.arraybuffer && preferBinary) {
		return 'arraybuffer'
	} else {
		return 'text'
	}
}

var ClientRequest = module.exports = function (opts) {
	var self = this
	stream.Writable.call(self)

	self._opts = opts
	self._body = []
	self._headers = {}
	if (opts.auth)
		self.setHeader('Authorization', 'Basic ' + Buffer.from(opts.auth).toString('base64'))
	Object.keys(opts.headers).forEach(function (name) {
		self.setHeader(name, opts.headers[name])
	})

	var preferBinary
	var useFetch = true
	if (opts.mode === 'disable-fetch' || ('requestTimeout' in opts && !capability.abortController)) {
		// If the use of XHR should be preferred. Not typically needed.
		useFetch = false
		preferBinary = true
	} else if (opts.mode === 'prefer-streaming') {
		// If streaming is a high priority but binary compatibility and
		// the accuracy of the 'content-type' header aren't
		preferBinary = false
	} else if (opts.mode === 'allow-wrong-content-type') {
		// If streaming is more important than preserving the 'content-type' header
		preferBinary = !capability.overrideMimeType
	} else if (!opts.mode || opts.mode === 'default' || opts.mode === 'prefer-fast') {
		// Use binary if text streaming may corrupt data or the content-type header, or for speed
		preferBinary = true
	} else {
		throw new Error('Invalid value for opts.mode')
	}
	self._mode = decideMode(preferBinary, useFetch)
	self._fetchTimer = null
	self._socketTimeout = null
	self._socketTimer = null

	self.on('finish', function () {
		self._onFinish()
	})
}

inherits(ClientRequest, stream.Writable)

ClientRequest.prototype.setHeader = function (name, value) {
	var self = this
	var lowerName = name.toLowerCase()
	// This check is not necessary, but it prevents warnings from browsers about setting unsafe
	// headers. To be honest I'm not entirely sure hiding these warnings is a good thing, but
	// http-browserify did it, so I will too.
	if (unsafeHeaders.indexOf(lowerName) !== -1)
		return

	self._headers[lowerName] = {
		name: name,
		value: value
	}
}

ClientRequest.prototype.getHeader = function (name) {
	var header = this._headers[name.toLowerCase()]
	if (header)
		return header.value
	return null
}

ClientRequest.prototype.removeHeader = function (name) {
	var self = this
	delete self._headers[name.toLowerCase()]
}

ClientRequest.prototype._onFinish = function () {
	var self = this

	if (self._destroyed)
		return
	var opts = self._opts

	if ('timeout' in opts && opts.timeout !== 0) {
		self.setTimeout(opts.timeout)
	}

	var headersObj = self._headers
	var body = null
	if (opts.method !== 'GET' && opts.method !== 'HEAD') {
        body = new Blob(self._body, {
            type: (headersObj['content-type'] || {}).value || ''
        });
    }

	// create flattened list of headers
	var headersList = []
	Object.keys(headersObj).forEach(function (keyName) {
		var name = headersObj[keyName].name
		var value = headersObj[keyName].value
		if (Array.isArray(value)) {
			value.forEach(function (v) {
				headersList.push([name, v])
			})
		} else {
			headersList.push([name, value])
		}
	})

	if (self._mode === 'fetch') {
		var signal = null
		if (capability.abortController) {
			var controller = new AbortController()
			signal = controller.signal
			self._fetchAbortController = controller

			if ('requestTimeout' in opts && opts.requestTimeout !== 0) {
				self._fetchTimer = global.setTimeout(function () {
					self.emit('requestTimeout')
					if (self._fetchAbortController)
						self._fetchAbortController.abort()
				}, opts.requestTimeout)
			}
		}

		global.fetch(self._opts.url, {
			method: self._opts.method,
			headers: headersList,
			body: body || undefined,
			mode: 'cors',
			credentials: opts.withCredentials ? 'include' : 'same-origin',
			signal: signal
		}).then(function (response) {
			self._fetchResponse = response
			self._resetTimers(false)
			self._connect()
		}, function (reason) {
			self._resetTimers(true)
			if (!self._destroyed)
				self.emit('error', reason)
		})
	} else {
		var xhr = self._xhr = new global.XMLHttpRequest()
		try {
			xhr.open(self._opts.method, self._opts.url, true)
		} catch (err) {
			process.nextTick(function () {
				self.emit('error', err)
			})
			return
		}

		// Can't set responseType on really old browsers
		if ('responseType' in xhr)
			xhr.responseType = self._mode

		if ('withCredentials' in xhr)
			xhr.withCredentials = !!opts.withCredentials

		if (self._mode === 'text' && 'overrideMimeType' in xhr)
			xhr.overrideMimeType('text/plain; charset=x-user-defined')

		if ('requestTimeout' in opts) {
			xhr.timeout = opts.requestTimeout
			xhr.ontimeout = function () {
				self.emit('requestTimeout')
			}
		}

		headersList.forEach(function (header) {
			xhr.setRequestHeader(header[0], header[1])
		})

		self._response = null
		xhr.onreadystatechange = function () {
			switch (xhr.readyState) {
				case rStates.LOADING:
				case rStates.DONE:
					self._onXHRProgress()
					break
			}
		}
		// Necessary for streaming in Firefox, since xhr.response is ONLY defined
		// in onprogress, not in onreadystatechange with xhr.readyState = 3
		if (self._mode === 'moz-chunked-arraybuffer') {
			xhr.onprogress = function () {
				self._onXHRProgress()
			}
		}

		xhr.onerror = function () {
			if (self._destroyed)
				return
			self._resetTimers(true)
			self.emit('error', new Error('XHR error'))
		}

		try {
			xhr.send(body)
		} catch (err) {
			process.nextTick(function () {
				self.emit('error', err)
			})
			return
		}
	}
}

/**
 * Checks if xhr.status is readable and non-zero, indicating no error.
 * Even though the spec says it should be available in readyState 3,
 * accessing it throws an exception in IE8
 */
function statusValid (xhr) {
	try {
		var status = xhr.status
		return (status !== null && status !== 0)
	} catch (e) {
		return false
	}
}

ClientRequest.prototype._onXHRProgress = function () {
	var self = this

	self._resetTimers(false)

	if (!statusValid(self._xhr) || self._destroyed)
		return

	if (!self._response)
		self._connect()

	self._response._onXHRProgress(self._resetTimers.bind(self))
}

ClientRequest.prototype._connect = function () {
	var self = this

	if (self._destroyed)
		return

	self._response = new IncomingMessage(self._xhr, self._fetchResponse, self._mode, self._resetTimers.bind(self))
	self._response.on('error', function(err) {
		self.emit('error', err)
	})

	self.emit('response', self._response)
}

ClientRequest.prototype._write = function (chunk, encoding, cb) {
	var self = this

	self._body.push(chunk)
	cb()
}

ClientRequest.prototype._resetTimers = function (done) {
	var self = this

	global.clearTimeout(self._socketTimer)
	self._socketTimer = null

	if (done) {
		global.clearTimeout(self._fetchTimer)
		self._fetchTimer = null
	} else if (self._socketTimeout) {
		self._socketTimer = global.setTimeout(function () {
			self.emit('timeout')
		}, self._socketTimeout)
	}
}

ClientRequest.prototype.abort = ClientRequest.prototype.destroy = function (err) {
	var self = this
	self._destroyed = true
	self._resetTimers(true)
	if (self._response)
		self._response._destroyed = true
	if (self._xhr)
		self._xhr.abort()
	else if (self._fetchAbortController)
		self._fetchAbortController.abort()

	if (err)
		self.emit('error', err)
}

ClientRequest.prototype.end = function (data, encoding, cb) {
	var self = this
	if (typeof data === 'function') {
		cb = data
		data = undefined
	}

	stream.Writable.prototype.end.call(self, data, encoding, cb)
}

ClientRequest.prototype.setTimeout = function (timeout, cb) {
	var self = this

	if (cb)
		self.once('timeout', cb)

	self._socketTimeout = timeout
	self._resetTimers(false)
}

ClientRequest.prototype.flushHeaders = function () {}
ClientRequest.prototype.setNoDelay = function () {}
ClientRequest.prototype.setSocketKeepAlive = function () {}

// Taken from http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader%28%29-method
var unsafeHeaders = [
	'accept-charset',
	'accept-encoding',
	'access-control-request-headers',
	'access-control-request-method',
	'connection',
	'content-length',
	'cookie',
	'cookie2',
	'date',
	'dnt',
	'expect',
	'host',
	'keep-alive',
	'origin',
	'referer',
	'te',
	'trailer',
	'transfer-encoding',
	'upgrade',
	'via'
]

}).call(this)}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)

},{"./capability":733,"./response":735,"_process":714,"buffer":81,"inherits":88,"readable-stream":750}],735:[function(require,module,exports){
(function (process,global,Buffer){(function (){
var capability = require('./capability')
var inherits = require('inherits')
var stream = require('readable-stream')

var rStates = exports.readyStates = {
	UNSENT: 0,
	OPENED: 1,
	HEADERS_RECEIVED: 2,
	LOADING: 3,
	DONE: 4
}

var IncomingMessage = exports.IncomingMessage = function (xhr, response, mode, resetTimers) {
	var self = this
	stream.Readable.call(self)

	self._mode = mode
	self.headers = {}
	self.rawHeaders = []
	self.trailers = {}
	self.rawTrailers = []

	// Fake the 'close' event, but only once 'end' fires
	self.on('end', function () {
		// The nextTick is necessary to prevent the 'request' module from causing an infinite loop
		process.nextTick(function () {
			self.emit('close')
		})
	})

	if (mode === 'fetch') {
		self._fetchResponse = response

		self.url = response.url
		self.statusCode = response.status
		self.statusMessage = response.statusText
		
		response.headers.forEach(function (header, key){
			self.headers[key.toLowerCase()] = header
			self.rawHeaders.push(key, header)
		})

		if (capability.writableStream) {
			var writable = new WritableStream({
				write: function (chunk) {
					resetTimers(false)
					return new Promise(function (resolve, reject) {
						if (self._destroyed) {
							reject()
						} else if(self.push(Buffer.from(chunk))) {
							resolve()
						} else {
							self._resumeFetch = resolve
						}
					})
				},
				close: function () {
					resetTimers(true)
					if (!self._destroyed)
						self.push(null)
				},
				abort: function (err) {
					resetTimers(true)
					if (!self._destroyed)
						self.emit('error', err)
				}
			})

			try {
				response.body.pipeTo(writable).catch(function (err) {
					resetTimers(true)
					if (!self._destroyed)
						self.emit('error', err)
				})
				return
			} catch (e) {} // pipeTo method isn't defined. Can't find a better way to feature test this
		}
		// fallback for when writableStream or pipeTo aren't available
		var reader = response.body.getReader()
		function read () {
			reader.read().then(function (result) {
				if (self._destroyed)
					return
				resetTimers(result.done)
				if (result.done) {
					self.push(null)
					return
				}
				self.push(Buffer.from(result.value))
				read()
			}).catch(function (err) {
				resetTimers(true)
				if (!self._destroyed)
					self.emit('error', err)
			})
		}
		read()
	} else {
		self._xhr = xhr
		self._pos = 0

		self.url = xhr.responseURL
		self.statusCode = xhr.status
		self.statusMessage = xhr.statusText
		var headers = xhr.getAllResponseHeaders().split(/\r?\n/)
		headers.forEach(function (header) {
			var matches = header.match(/^([^:]+):\s*(.*)/)
			if (matches) {
				var key = matches[1].toLowerCase()
				if (key === 'set-cookie') {
					if (self.headers[key] === undefined) {
						self.headers[key] = []
					}
					self.headers[key].push(matches[2])
				} else if (self.headers[key] !== undefined) {
					self.headers[key] += ', ' + matches[2]
				} else {
					self.headers[key] = matches[2]
				}
				self.rawHeaders.push(matches[1], matches[2])
			}
		})

		self._charset = 'x-user-defined'
		if (!capability.overrideMimeType) {
			var mimeType = self.rawHeaders['mime-type']
			if (mimeType) {
				var charsetMatch = mimeType.match(/;\s*charset=([^;])(;|$)/)
				if (charsetMatch) {
					self._charset = charsetMatch[1].toLowerCase()
				}
			}
			if (!self._charset)
				self._charset = 'utf-8' // best guess
		}
	}
}

inherits(IncomingMessage, stream.Readable)

IncomingMessage.prototype._read = function () {
	var self = this

	var resolve = self._resumeFetch
	if (resolve) {
		self._resumeFetch = null
		resolve()
	}
}

IncomingMessage.prototype._onXHRProgress = function (resetTimers) {
	var self = this

	var xhr = self._xhr

	var response = null
	switch (self._mode) {
		case 'text':
			response = xhr.responseText
			if (response.length > self._pos) {
				var newData = response.substr(self._pos)
				if (self._charset === 'x-user-defined') {
					var buffer = Buffer.alloc(newData.length)
					for (var i = 0; i < newData.length; i++)
						buffer[i] = newData.charCodeAt(i) & 0xff

					self.push(buffer)
				} else {
					self.push(newData, self._charset)
				}
				self._pos = response.length
			}
			break
		case 'arraybuffer':
			if (xhr.readyState !== rStates.DONE || !xhr.response)
				break
			response = xhr.response
			self.push(Buffer.from(new Uint8Array(response)))
			break
		case 'moz-chunked-arraybuffer': // take whole
			response = xhr.response
			if (xhr.readyState !== rStates.LOADING || !response)
				break
			self.push(Buffer.from(new Uint8Array(response)))
			break
		case 'ms-stream':
			response = xhr.response
			if (xhr.readyState !== rStates.LOADING)
				break
			var reader = new global.MSStreamReader()
			reader.onprogress = function () {
				if (reader.result.byteLength > self._pos) {
					self.push(Buffer.from(new Uint8Array(reader.result.slice(self._pos))))
					self._pos = reader.result.byteLength
				}
			}
			reader.onload = function () {
				resetTimers(true)
				self.push(null)
			}
			// reader.onerror = ??? // TODO: this
			reader.readAsArrayBuffer(response)
			break
	}

	// The ms-stream case handles end separately in reader.onload()
	if (self._xhr.readyState === rStates.DONE && self._mode !== 'ms-stream') {
		resetTimers(true)
		self.push(null)
	}
}

}).call(this)}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)

},{"./capability":733,"_process":714,"buffer":81,"inherits":88,"readable-stream":750}],736:[function(require,module,exports){
'use strict';

function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }

var codes = {};

function createErrorType(code, message, Base) {
  if (!Base) {
    Base = Error;
  }

  function getMessage(arg1, arg2, arg3) {
    if (typeof message === 'string') {
      return message;
    } else {
      return message(arg1, arg2, arg3);
    }
  }

  var NodeError =
  /*#__PURE__*/
  function (_Base) {
    _inheritsLoose(NodeError, _Base);

    function NodeError(arg1, arg2, arg3) {
      return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;
    }

    return NodeError;
  }(Base);

  NodeError.prototype.name = Base.name;
  NodeError.prototype.code = code;
  codes[code] = NodeError;
} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js


function oneOf(expected, thing) {
  if (Array.isArray(expected)) {
    var len = expected.length;
    expected = expected.map(function (i) {
      return String(i);
    });

    if (len > 2) {
      return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(', '), ", or ") + expected[len - 1];
    } else if (len === 2) {
      return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
    } else {
      return "of ".concat(thing, " ").concat(expected[0]);
    }
  } else {
    return "of ".concat(thing, " ").concat(String(expected));
  }
} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith


function startsWith(str, search, pos) {
  return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith


function endsWith(str, search, this_len) {
  if (this_len === undefined || this_len > str.length) {
    this_len = str.length;
  }

  return str.substring(this_len - search.length, this_len) === search;
} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes


function includes(str, search, start) {
  if (typeof start !== 'number') {
    start = 0;
  }

  if (start + search.length > str.length) {
    return false;
  } else {
    return str.indexOf(search, start) !== -1;
  }
}

createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
  return 'The value "' + value + '" is invalid for option "' + name + '"';
}, TypeError);
createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
  // determiner: 'must be' or 'must not be'
  var determiner;

  if (typeof expected === 'string' && startsWith(expected, 'not ')) {
    determiner = 'must not be';
    expected = expected.replace(/^not /, '');
  } else {
    determiner = 'must be';
  }

  var msg;

  if (endsWith(name, ' argument')) {
    // For cases like 'first argument'
    msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
  } else {
    var type = includes(name, '.') ? 'property' : 'argument';
    msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
  }

  msg += ". Received type ".concat(typeof actual);
  return msg;
}, TypeError);
createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {
  return 'The ' + name + ' method is not implemented';
});
createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');
createErrorType('ERR_STREAM_DESTROYED', function (name) {
  return 'Cannot call ' + name + ' after a stream was destroyed';
});
createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');
createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
  return 'Unknown encoding: ' + arg;
}, TypeError);
createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
module.exports.codes = codes;

},{}],737:[function(require,module,exports){
(function (process){(function (){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// a duplex stream is just a stream that is both readable and writable.
// Since JS doesn't have multiple prototypal inheritance, this class
// prototypally inherits from Readable, and then parasitically from
// Writable.
'use strict';
/*<replacement>*/

var objectKeys = Object.keys || function (obj) {
  var keys = [];

  for (var key in obj) {
    keys.push(key);
  }

  return keys;
};
/*</replacement>*/


module.exports = Duplex;

var Readable = require('./_stream_readable');

var Writable = require('./_stream_writable');

require('inherits')(Duplex, Readable);

{
  // Allow the keys array to be GC'ed.
  var keys = objectKeys(Writable.prototype);

  for (var v = 0; v < keys.length; v++) {
    var method = keys[v];
    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
  }
}

function Duplex(options) {
  if (!(this instanceof Duplex)) return new Duplex(options);
  Readable.call(this, options);
  Writable.call(this, options);
  this.allowHalfOpen = true;

  if (options) {
    if (options.readable === false) this.readable = false;
    if (options.writable === false) this.writable = false;

    if (options.allowHalfOpen === false) {
      this.allowHalfOpen = false;
      this.once('end', onend);
    }
  }
}

Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
  // making it explicit this property is not enumerable
  // because otherwise some prototype manipulation in
  // userland will fail
  enumerable: false,
  get: function get() {
    return this._writableState.highWaterMark;
  }
});
Object.defineProperty(Duplex.prototype, 'writableBuffer', {
  // making it explicit this property is not enumerable
  // because otherwise some prototype manipulation in
  // userland will fail
  enumerable: false,
  get: function get() {
    return this._writableState && this._writableState.getBuffer();
  }
});
Object.defineProperty(Duplex.prototype, 'writableLength', {
  // making it explicit this property is not enumerable
  // because otherwise some prototype manipulation in
  // userland will fail
  enumerable: false,
  get: function get() {
    return this._writableState.length;
  }
}); // the no-half-open enforcer

function onend() {
  // If the writable side ended, then we're ok.
  if (this._writableState.ended) return; // no more data can be written.
  // But allow more writes to happen in this tick.

  process.nextTick(onEndNT, this);
}

function onEndNT(self) {
  self.end();
}

Object.defineProperty(Duplex.prototype, 'destroyed', {
  // making it explicit this property is not enumerable
  // because otherwise some prototype manipulation in
  // userland will fail
  enumerable: false,
  get: function get() {
    if (this._readableState === undefined || this._writableState === undefined) {
      return false;
    }

    return this._readableState.destroyed && this._writableState.destroyed;
  },
  set: function set(value) {
    // we ignore the value if the stream
    // has not been initialized yet
    if (this._readableState === undefined || this._writableState === undefined) {
      return;
    } // backward compatibility, the user is explicitly
    // managing destroyed


    this._readableState.destroyed = value;
    this._writableState.destroyed = value;
  }
});
}).call(this)}).call(this,require('_process'))

},{"./_stream_readable":739,"./_stream_writable":741,"_process":714,"inherits":88}],738:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// a passthrough stream.
// basically just the most minimal sort of Transform stream.
// Every written chunk gets output as-is.
'use strict';

module.exports = PassThrough;

var Transform = require('./_stream_transform');

require('inherits')(PassThrough, Transform);

function PassThrough(options) {
  if (!(this instanceof PassThrough)) return new PassThrough(options);
  Transform.call(this, options);
}

PassThrough.prototype._transform = function (chunk, encoding, cb) {
  cb(null, chunk);
};
},{"./_stream_transform":740,"inherits":88}],739:[function(require,module,exports){
(function (process,global){(function (){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
'use strict';

module.exports = Readable;
/*<replacement>*/

var Duplex;
/*</replacement>*/

Readable.ReadableState = ReadableState;
/*<replacement>*/

var EE = require('events').EventEmitter;

var EElistenerCount = function EElistenerCount(emitter, type) {
  return emitter.listeners(type).length;
};
/*</replacement>*/

/*<replacement>*/


var Stream = require('./internal/streams/stream');
/*</replacement>*/


var Buffer = require('buffer').Buffer;

var OurUint8Array = global.Uint8Array || function () {};

function _uint8ArrayToBuffer(chunk) {
  return Buffer.from(chunk);
}

function _isUint8Array(obj) {
  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
}
/*<replacement>*/


var debugUtil = require('util');

var debug;

if (debugUtil && debugUtil.debuglog) {
  debug = debugUtil.debuglog('stream');
} else {
  debug = function debug() {};
}
/*</replacement>*/


var BufferList = require('./internal/streams/buffer_list');

var destroyImpl = require('./internal/streams/destroy');

var _require = require('./internal/streams/state'),
    getHighWaterMark = _require.getHighWaterMark;

var _require$codes = require('../errors').codes,
    ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
    ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,
    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
    ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT; // Lazy loaded to improve the startup performance.


var StringDecoder;
var createReadableStreamAsyncIterator;
var from;

require('inherits')(Readable, Stream);

var errorOrDestroy = destroyImpl.errorOrDestroy;
var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];

function prependListener(emitter, event, fn) {
  // Sadly this is not cacheable as some libraries bundle their own
  // event emitter implementation with them.
  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); // This is a hack to make sure that our error handler is attached before any
  // userland ones.  NEVER DO THIS. This is here only because this code needs
  // to continue to work with older versions of Node.js that do not include
  // the prependListener() method. The goal is to eventually remove this hack.

  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
}

function ReadableState(options, stream, isDuplex) {
  Duplex = Duplex || require('./_stream_duplex');
  options = options || {}; // Duplex streams are both readable and writable, but share
  // the same options object.
  // However, some cases require setting options to different
  // values for the readable and the writable sides of the duplex stream.
  // These options can be provided separately as readableXXX and writableXXX.

  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to
  // make all the buffer merging and length checks go away

  this.objectMode = !!options.objectMode;
  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at which it stops calling _read() to fill the buffer
  // Note: 0 is a valid value, means "don't call _read preemptively ever"

  this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A linked list is used to store data chunks instead of an array because the
  // linked list can remove elements from the beginning faster than
  // array.shift()

  this.buffer = new BufferList();
  this.length = 0;
  this.pipes = null;
  this.pipesCount = 0;
  this.flowing = null;
  this.ended = false;
  this.endEmitted = false;
  this.reading = false; // a flag to be able to tell if the event 'readable'/'data' is emitted
  // immediately, or on a later tick.  We set this to true at first, because
  // any actions that shouldn't happen until "later" should generally also
  // not happen before the first read call.

  this.sync = true; // whenever we return null, then we set a flag to say
  // that we're awaiting a 'readable' event emission.

  this.needReadable = false;
  this.emittedReadable = false;
  this.readableListening = false;
  this.resumeScheduled = false;
  this.paused = true; // Should close be emitted on destroy. Defaults to true.

  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish')

  this.autoDestroy = !!options.autoDestroy; // has it been destroyed

  this.destroyed = false; // Crypto is kind of old and crusty.  Historically, its default string
  // encoding is 'binary' so we have to make this configurable.
  // Everything else in the universe uses 'utf8', though.

  this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s

  this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled

  this.readingMore = false;
  this.decoder = null;
  this.encoding = null;

  if (options.encoding) {
    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
    this.decoder = new StringDecoder(options.encoding);
    this.encoding = options.encoding;
  }
}

function Readable(options) {
  Duplex = Duplex || require('./_stream_duplex');
  if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside
  // the ReadableState constructor, at least with V8 6.5

  var isDuplex = this instanceof Duplex;
  this._readableState = new ReadableState(options, this, isDuplex); // legacy

  this.readable = true;

  if (options) {
    if (typeof options.read === 'function') this._read = options.read;
    if (typeof options.destroy === 'function') this._destroy = options.destroy;
  }

  Stream.call(this);
}

Object.defineProperty(Readable.prototype, 'destroyed', {
  // making it explicit this property is not enumerable
  // because otherwise some prototype manipulation in
  // userland will fail
  enumerable: false,
  get: function get() {
    if (this._readableState === undefined) {
      return false;
    }

    return this._readableState.destroyed;
  },
  set: function set(value) {
    // we ignore the value if the stream
    // has not been initialized yet
    if (!this._readableState) {
      return;
    } // backward compatibility, the user is explicitly
    // managing destroyed


    this._readableState.destroyed = value;
  }
});
Readable.prototype.destroy = destroyImpl.destroy;
Readable.prototype._undestroy = destroyImpl.undestroy;

Readable.prototype._destroy = function (err, cb) {
  cb(err);
}; // Manually shove something into the read() buffer.
// This returns true if the highWaterMark has not been hit yet,
// similar to how Writable.write() returns true if you should
// write() some more.


Readable.prototype.push = function (chunk, encoding) {
  var state = this._readableState;
  var skipChunkCheck;

  if (!state.objectMode) {
    if (typeof chunk === 'string') {
      encoding = encoding || state.defaultEncoding;

      if (encoding !== state.encoding) {
        chunk = Buffer.from(chunk, encoding);
        encoding = '';
      }

      skipChunkCheck = true;
    }
  } else {
    skipChunkCheck = true;
  }

  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
}; // Unshift should *always* be something directly out of read()


Readable.prototype.unshift = function (chunk) {
  return readableAddChunk(this, chunk, null, true, false);
};

function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
  debug('readableAddChunk', chunk);
  var state = stream._readableState;

  if (chunk === null) {
    state.reading = false;
    onEofChunk(stream, state);
  } else {
    var er;
    if (!skipChunkCheck) er = chunkInvalid(state, chunk);

    if (er) {
      errorOrDestroy(stream, er);
    } else if (state.objectMode || chunk && chunk.length > 0) {
      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
        chunk = _uint8ArrayToBuffer(chunk);
      }

      if (addToFront) {
        if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);
      } else if (state.ended) {
        errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());
      } else if (state.destroyed) {
        return false;
      } else {
        state.reading = false;

        if (state.decoder && !encoding) {
          chunk = state.decoder.write(chunk);
          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
        } else {
          addChunk(stream, state, chunk, false);
        }
      }
    } else if (!addToFront) {
      state.reading = false;
      maybeReadMore(stream, state);
    }
  } // We can push more data if we are below the highWaterMark.
  // Also, if we have no data yet, we can stand some more bytes.
  // This is to work around cases where hwm=0, such as the repl.


  return !state.ended && (state.length < state.highWaterMark || state.length === 0);
}

function addChunk(stream, state, chunk, addToFront) {
  if (state.flowing && state.length === 0 && !state.sync) {
    state.awaitDrain = 0;
    stream.emit('data', chunk);
  } else {
    // update the buffer info.
    state.length += state.objectMode ? 1 : chunk.length;
    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
    if (state.needReadable) emitReadable(stream);
  }

  maybeReadMore(stream, state);
}

function chunkInvalid(state, chunk) {
  var er;

  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);
  }

  return er;
}

Readable.prototype.isPaused = function () {
  return this._readableState.flowing === false;
}; // backwards compatibility.


Readable.prototype.setEncoding = function (enc) {
  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
  var decoder = new StringDecoder(enc);
  this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8

  this._readableState.encoding = this._readableState.decoder.encoding; // Iterate over current buffer to convert already stored Buffers:

  var p = this._readableState.buffer.head;
  var content = '';

  while (p !== null) {
    content += decoder.write(p.data);
    p = p.next;
  }

  this._readableState.buffer.clear();

  if (content !== '') this._readableState.buffer.push(content);
  this._readableState.length = content.length;
  return this;
}; // Don't raise the hwm > 1GB


var MAX_HWM = 0x40000000;

function computeNewHighWaterMark(n) {
  if (n >= MAX_HWM) {
    // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.
    n = MAX_HWM;
  } else {
    // Get the next highest power of 2 to prevent increasing hwm excessively in
    // tiny amounts
    n--;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    n++;
  }

  return n;
} // This function is designed to be inlinable, so please take care when making
// changes to the function body.


function howMuchToRead(n, state) {
  if (n <= 0 || state.length === 0 && state.ended) return 0;
  if (state.objectMode) return 1;

  if (n !== n) {
    // Only flow one buffer at a time
    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
  } // If we're asking for more than the current hwm, then raise the hwm.


  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
  if (n <= state.length) return n; // Don't have enough

  if (!state.ended) {
    state.needReadable = true;
    return 0;
  }

  return state.length;
} // you can override either this method, or the async _read(n) below.


Readable.prototype.read = function (n) {
  debug('read', n);
  n = parseInt(n, 10);
  var state = this._readableState;
  var nOrig = n;
  if (n !== 0) state.emittedReadable = false; // if we're doing read(0) to trigger a readable event, but we
  // already have a bunch of data in the buffer, then just trigger
  // the 'readable' event and move on.

  if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {
    debug('read: emitReadable', state.length, state.ended);
    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
    return null;
  }

  n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up.

  if (n === 0 && state.ended) {
    if (state.length === 0) endReadable(this);
    return null;
  } // All the actual chunk generation logic needs to be
  // *below* the call to _read.  The reason is that in certain
  // synthetic stream cases, such as passthrough streams, _read
  // may be a completely synchronous operation which may change
  // the state of the read buffer, providing enough data when
  // before there was *not* enough.
  //
  // So, the steps are:
  // 1. Figure out what the state of things will be after we do
  // a read from the buffer.
  //
  // 2. If that resulting state will trigger a _read, then call _read.
  // Note that this may be asynchronous, or synchronous.  Yes, it is
  // deeply ugly to write APIs this way, but that still doesn't mean
  // that the Readable class should behave improperly, as streams are
  // designed to be sync/async agnostic.
  // Take note if the _read call is sync or async (ie, if the read call
  // has returned yet), so that we know whether or not it's safe to emit
  // 'readable' etc.
  //
  // 3. Actually pull the requested chunks out of the buffer and return.
  // if we need a readable event, then we need to do some reading.


  var doRead = state.needReadable;
  debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some

  if (state.length === 0 || state.length - n < state.highWaterMark) {
    doRead = true;
    debug('length less than watermark', doRead);
  } // however, if we've ended, then there's no point, and if we're already
  // reading, then it's unnecessary.


  if (state.ended || state.reading) {
    doRead = false;
    debug('reading or ended', doRead);
  } else if (doRead) {
    debug('do read');
    state.reading = true;
    state.sync = true; // if the length is currently zero, then we *need* a readable event.

    if (state.length === 0) state.needReadable = true; // call internal read method

    this._read(state.highWaterMark);

    state.sync = false; // If _read pushed data synchronously, then `reading` will be false,
    // and we need to re-evaluate how much data we can return to the user.

    if (!state.reading) n = howMuchToRead(nOrig, state);
  }

  var ret;
  if (n > 0) ret = fromList(n, state);else ret = null;

  if (ret === null) {
    state.needReadable = state.length <= state.highWaterMark;
    n = 0;
  } else {
    state.length -= n;
    state.awaitDrain = 0;
  }

  if (state.length === 0) {
    // If we have nothing in the buffer, then we want to know
    // as soon as we *do* get something into the buffer.
    if (!state.ended) state.needReadable = true; // If we tried to read() past the EOF, then emit end on the next tick.

    if (nOrig !== n && state.ended) endReadable(this);
  }

  if (ret !== null) this.emit('data', ret);
  return ret;
};

function onEofChunk(stream, state) {
  debug('onEofChunk');
  if (state.ended) return;

  if (state.decoder) {
    var chunk = state.decoder.end();

    if (chunk && chunk.length) {
      state.buffer.push(chunk);
      state.length += state.objectMode ? 1 : chunk.length;
    }
  }

  state.ended = true;

  if (state.sync) {
    // if we are sync, wait until next tick to emit the data.
    // Otherwise we risk emitting data in the flow()
    // the readable code triggers during a read() call
    emitReadable(stream);
  } else {
    // emit 'readable' now to make sure it gets picked up.
    state.needReadable = false;

    if (!state.emittedReadable) {
      state.emittedReadable = true;
      emitReadable_(stream);
    }
  }
} // Don't emit readable right away in sync mode, because this can trigger
// another read() call => stack overflow.  This way, it might trigger
// a nextTick recursion warning, but that's not so bad.


function emitReadable(stream) {
  var state = stream._readableState;
  debug('emitReadable', state.needReadable, state.emittedReadable);
  state.needReadable = false;

  if (!state.emittedReadable) {
    debug('emitReadable', state.flowing);
    state.emittedReadable = true;
    process.nextTick(emitReadable_, stream);
  }
}

function emitReadable_(stream) {
  var state = stream._readableState;
  debug('emitReadable_', state.destroyed, state.length, state.ended);

  if (!state.destroyed && (state.length || state.ended)) {
    stream.emit('readable');
    state.emittedReadable = false;
  } // The stream needs another readable event if
  // 1. It is not flowing, as the flow mechanism will take
  //    care of it.
  // 2. It is not ended.
  // 3. It is below the highWaterMark, so we can schedule
  //    another readable later.


  state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;
  flow(stream);
} // at this point, the user has presumably seen the 'readable' event,
// and called read() to consume some data.  that may have triggered
// in turn another _read(n) call, in which case reading = true if
// it's in progress.
// However, if we're not ended, or reading, and the length < hwm,
// then go ahead and try to read some more preemptively.


function maybeReadMore(stream, state) {
  if (!state.readingMore) {
    state.readingMore = true;
    process.nextTick(maybeReadMore_, stream, state);
  }
}

function maybeReadMore_(stream, state) {
  // Attempt to read more data if we should.
  //
  // The conditions for reading more data are (one of):
  // - Not enough data buffered (state.length < state.highWaterMark). The loop
  //   is responsible for filling the buffer with enough data if such data
  //   is available. If highWaterMark is 0 and we are not in the flowing mode
  //   we should _not_ attempt to buffer any extra data. We'll get more data
  //   when the stream consumer calls read() instead.
  // - No data in the buffer, and the stream is in flowing mode. In this mode
  //   the loop below is responsible for ensuring read() is called. Failing to
  //   call read here would abort the flow and there's no other mechanism for
  //   continuing the flow if the stream consumer has just subscribed to the
  //   'data' event.
  //
  // In addition to the above conditions to keep reading data, the following
  // conditions prevent the data from being read:
  // - The stream has ended (state.ended).
  // - There is already a pending 'read' operation (state.reading). This is a
  //   case where the the stream has called the implementation defined _read()
  //   method, but they are processing the call asynchronously and have _not_
  //   called push() with new data. In this case we skip performing more
  //   read()s. The execution ends in this method again after the _read() ends
  //   up calling push() with more data.
  while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {
    var len = state.length;
    debug('maybeReadMore read 0');
    stream.read(0);
    if (len === state.length) // didn't get any data, stop spinning.
      break;
  }

  state.readingMore = false;
} // abstract method.  to be overridden in specific implementation classes.
// call cb(er, data) where data is <= n in length.
// for virtual (non-string, non-buffer) streams, "length" is somewhat
// arbitrary, and perhaps not very meaningful.


Readable.prototype._read = function (n) {
  errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));
};

Readable.prototype.pipe = function (dest, pipeOpts) {
  var src = this;
  var state = this._readableState;

  switch (state.pipesCount) {
    case 0:
      state.pipes = dest;
      break;

    case 1:
      state.pipes = [state.pipes, dest];
      break;

    default:
      state.pipes.push(dest);
      break;
  }

  state.pipesCount += 1;
  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
  var endFn = doEnd ? onend : unpipe;
  if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);
  dest.on('unpipe', onunpipe);

  function onunpipe(readable, unpipeInfo) {
    debug('onunpipe');

    if (readable === src) {
      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
        unpipeInfo.hasUnpiped = true;
        cleanup();
      }
    }
  }

  function onend() {
    debug('onend');
    dest.end();
  } // when the dest drains, it reduces the awaitDrain counter
  // on the source.  This would be more elegant with a .once()
  // handler in flow(), but adding and removing repeatedly is
  // too slow.


  var ondrain = pipeOnDrain(src);
  dest.on('drain', ondrain);
  var cleanedUp = false;

  function cleanup() {
    debug('cleanup'); // cleanup event handlers once the pipe is broken

    dest.removeListener('close', onclose);
    dest.removeListener('finish', onfinish);
    dest.removeListener('drain', ondrain);
    dest.removeListener('error', onerror);
    dest.removeListener('unpipe', onunpipe);
    src.removeListener('end', onend);
    src.removeListener('end', unpipe);
    src.removeListener('data', ondata);
    cleanedUp = true; // if the reader is waiting for a drain event from this
    // specific writer, then it would cause it to never start
    // flowing again.
    // So, if this is awaiting a drain, then we just call it now.
    // If we don't know, then assume that we are waiting for one.

    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
  }

  src.on('data', ondata);

  function ondata(chunk) {
    debug('ondata');
    var ret = dest.write(chunk);
    debug('dest.write', ret);

    if (ret === false) {
      // If the user unpiped during `dest.write()`, it is possible
      // to get stuck in a permanently paused state if that write
      // also returned false.
      // => Check whether `dest` is still a piping destination.
      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
        debug('false write response, pause', state.awaitDrain);
        state.awaitDrain++;
      }

      src.pause();
    }
  } // if the dest has an error, then stop piping into it.
  // however, don't suppress the throwing behavior for this.


  function onerror(er) {
    debug('onerror', er);
    unpipe();
    dest.removeListener('error', onerror);
    if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er);
  } // Make sure our error handler is attached before userland ones.


  prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once.

  function onclose() {
    dest.removeListener('finish', onfinish);
    unpipe();
  }

  dest.once('close', onclose);

  function onfinish() {
    debug('onfinish');
    dest.removeListener('close', onclose);
    unpipe();
  }

  dest.once('finish', onfinish);

  function unpipe() {
    debug('unpipe');
    src.unpipe(dest);
  } // tell the dest that it's being piped to


  dest.emit('pipe', src); // start the flow if it hasn't been started already.

  if (!state.flowing) {
    debug('pipe resume');
    src.resume();
  }

  return dest;
};

function pipeOnDrain(src) {
  return function pipeOnDrainFunctionResult() {
    var state = src._readableState;
    debug('pipeOnDrain', state.awaitDrain);
    if (state.awaitDrain) state.awaitDrain--;

    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
      state.flowing = true;
      flow(src);
    }
  };
}

Readable.prototype.unpipe = function (dest) {
  var state = this._readableState;
  var unpipeInfo = {
    hasUnpiped: false
  }; // if we're not piping anywhere, then do nothing.

  if (state.pipesCount === 0) return this; // just one destination.  most common case.

  if (state.pipesCount === 1) {
    // passed in one, but it's not the right one.
    if (dest && dest !== state.pipes) return this;
    if (!dest) dest = state.pipes; // got a match.

    state.pipes = null;
    state.pipesCount = 0;
    state.flowing = false;
    if (dest) dest.emit('unpipe', this, unpipeInfo);
    return this;
  } // slow case. multiple pipe destinations.


  if (!dest) {
    // remove all.
    var dests = state.pipes;
    var len = state.pipesCount;
    state.pipes = null;
    state.pipesCount = 0;
    state.flowing = false;

    for (var i = 0; i < len; i++) {
      dests[i].emit('unpipe', this, {
        hasUnpiped: false
      });
    }

    return this;
  } // try to find the right one.


  var index = indexOf(state.pipes, dest);
  if (index === -1) return this;
  state.pipes.splice(index, 1);
  state.pipesCount -= 1;
  if (state.pipesCount === 1) state.pipes = state.pipes[0];
  dest.emit('unpipe', this, unpipeInfo);
  return this;
}; // set up data events if they are asked for
// Ensure readable listeners eventually get something


Readable.prototype.on = function (ev, fn) {
  var res = Stream.prototype.on.call(this, ev, fn);
  var state = this._readableState;

  if (ev === 'data') {
    // update readableListening so that resume() may be a no-op
    // a few lines down. This is needed to support once('readable').
    state.readableListening = this.listenerCount('readable') > 0; // Try start flowing on next tick if stream isn't explicitly paused

    if (state.flowing !== false) this.resume();
  } else if (ev === 'readable') {
    if (!state.endEmitted && !state.readableListening) {
      state.readableListening = state.needReadable = true;
      state.flowing = false;
      state.emittedReadable = false;
      debug('on readable', state.length, state.reading);

      if (state.length) {
        emitReadable(this);
      } else if (!state.reading) {
        process.nextTick(nReadingNextTick, this);
      }
    }
  }

  return res;
};

Readable.prototype.addListener = Readable.prototype.on;

Readable.prototype.removeListener = function (ev, fn) {
  var res = Stream.prototype.removeListener.call(this, ev, fn);

  if (ev === 'readable') {
    // We need to check if there is someone still listening to
    // readable and reset the state. However this needs to happen
    // after readable has been emitted but before I/O (nextTick) to
    // support once('readable', fn) cycles. This means that calling
    // resume within the same tick will have no
    // effect.
    process.nextTick(updateReadableListening, this);
  }

  return res;
};

Readable.prototype.removeAllListeners = function (ev) {
  var res = Stream.prototype.removeAllListeners.apply(this, arguments);

  if (ev === 'readable' || ev === undefined) {
    // We need to check if there is someone still listening to
    // readable and reset the state. However this needs to happen
    // after readable has been emitted but before I/O (nextTick) to
    // support once('readable', fn) cycles. This means that calling
    // resume within the same tick will have no
    // effect.
    process.nextTick(updateReadableListening, this);
  }

  return res;
};

function updateReadableListening(self) {
  var state = self._readableState;
  state.readableListening = self.listenerCount('readable') > 0;

  if (state.resumeScheduled && !state.paused) {
    // flowing needs to be set to true now, otherwise
    // the upcoming resume will not flow.
    state.flowing = true; // crude way to check if we should resume
  } else if (self.listenerCount('data') > 0) {
    self.resume();
  }
}

function nReadingNextTick(self) {
  debug('readable nexttick read 0');
  self.read(0);
} // pause() and resume() are remnants of the legacy readable stream API
// If the user uses them, then switch into old mode.


Readable.prototype.resume = function () {
  var state = this._readableState;

  if (!state.flowing) {
    debug('resume'); // we flow only if there is no one listening
    // for readable, but we still have to call
    // resume()

    state.flowing = !state.readableListening;
    resume(this, state);
  }

  state.paused = false;
  return this;
};

function resume(stream, state) {
  if (!state.resumeScheduled) {
    state.resumeScheduled = true;
    process.nextTick(resume_, stream, state);
  }
}

function resume_(stream, state) {
  debug('resume', state.reading);

  if (!state.reading) {
    stream.read(0);
  }

  state.resumeScheduled = false;
  stream.emit('resume');
  flow(stream);
  if (state.flowing && !state.reading) stream.read(0);
}

Readable.prototype.pause = function () {
  debug('call pause flowing=%j', this._readableState.flowing);

  if (this._readableState.flowing !== false) {
    debug('pause');
    this._readableState.flowing = false;
    this.emit('pause');
  }

  this._readableState.paused = true;
  return this;
};

function flow(stream) {
  var state = stream._readableState;
  debug('flow', state.flowing);

  while (state.flowing && stream.read() !== null) {
    ;
  }
} // wrap an old-style stream as the async data source.
// This is *not* part of the readable stream interface.
// It is an ugly unfortunate mess of history.


Readable.prototype.wrap = function (stream) {
  var _this = this;

  var state = this._readableState;
  var paused = false;
  stream.on('end', function () {
    debug('wrapped end');

    if (state.decoder && !state.ended) {
      var chunk = state.decoder.end();
      if (chunk && chunk.length) _this.push(chunk);
    }

    _this.push(null);
  });
  stream.on('data', function (chunk) {
    debug('wrapped data');
    if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode

    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;

    var ret = _this.push(chunk);

    if (!ret) {
      paused = true;
      stream.pause();
    }
  }); // proxy all the other methods.
  // important when wrapping filters and duplexes.

  for (var i in stream) {
    if (this[i] === undefined && typeof stream[i] === 'function') {
      this[i] = function methodWrap(method) {
        return function methodWrapReturnFunction() {
          return stream[method].apply(stream, arguments);
        };
      }(i);
    }
  } // proxy certain important events.


  for (var n = 0; n < kProxyEvents.length; n++) {
    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
  } // when we try to consume some more bytes, simply unpause the
  // underlying stream.


  this._read = function (n) {
    debug('wrapped _read', n);

    if (paused) {
      paused = false;
      stream.resume();
    }
  };

  return this;
};

if (typeof Symbol === 'function') {
  Readable.prototype[Symbol.asyncIterator] = function () {
    if (createReadableStreamAsyncIterator === undefined) {
      createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');
    }

    return createReadableStreamAsyncIterator(this);
  };
}

Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
  // making it explicit this property is not enumerable
  // because otherwise some prototype manipulation in
  // userland will fail
  enumerable: false,
  get: function get() {
    return this._readableState.highWaterMark;
  }
});
Object.defineProperty(Readable.prototype, 'readableBuffer', {
  // making it explicit this property is not enumerable
  // because otherwise some prototype manipulation in
  // userland will fail
  enumerable: false,
  get: function get() {
    return this._readableState && this._readableState.buffer;
  }
});
Object.defineProperty(Readable.prototype, 'readableFlowing', {
  // making it explicit this property is not enumerable
  // because otherwise some prototype manipulation in
  // userland will fail
  enumerable: false,
  get: function get() {
    return this._readableState.flowing;
  },
  set: function set(state) {
    if (this._readableState) {
      this._readableState.flowing = state;
    }
  }
}); // exposed for testing purposes only.

Readable._fromList = fromList;
Object.defineProperty(Readable.prototype, 'readableLength', {
  // making it explicit this property is not enumerable
  // because otherwise some prototype manipulation in
  // userland will fail
  enumerable: false,
  get: function get() {
    return this._readableState.length;
  }
}); // Pluck off n bytes from an array of buffers.
// Length is the combined lengths of all the buffers in the list.
// This function is designed to be inlinable, so please take care when making
// changes to the function body.

function fromList(n, state) {
  // nothing buffered
  if (state.length === 0) return null;
  var ret;
  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
    // read it all, truncate the list
    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);
    state.buffer.clear();
  } else {
    // read part of list
    ret = state.buffer.consume(n, state.decoder);
  }
  return ret;
}

function endReadable(stream) {
  var state = stream._readableState;
  debug('endReadable', state.endEmitted);

  if (!state.endEmitted) {
    state.ended = true;
    process.nextTick(endReadableNT, state, stream);
  }
}

function endReadableNT(state, stream) {
  debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.

  if (!state.endEmitted && state.length === 0) {
    state.endEmitted = true;
    stream.readable = false;
    stream.emit('end');

    if (state.autoDestroy) {
      // In case of duplex streams we need a way to detect
      // if the writable side is ready for autoDestroy as well
      var wState = stream._writableState;

      if (!wState || wState.autoDestroy && wState.finished) {
        stream.destroy();
      }
    }
  }
}

if (typeof Symbol === 'function') {
  Readable.from = function (iterable, opts) {
    if (from === undefined) {
      from = require('./internal/streams/from');
    }

    return from(Readable, iterable, opts);
  };
}

function indexOf(xs, x) {
  for (var i = 0, l = xs.length; i < l; i++) {
    if (xs[i] === x) return i;
  }

  return -1;
}
}).call(this)}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{"../errors":736,"./_stream_duplex":737,"./internal/streams/async_iterator":742,"./internal/streams/buffer_list":743,"./internal/streams/destroy":744,"./internal/streams/from":746,"./internal/streams/state":748,"./internal/streams/stream":749,"_process":714,"buffer":81,"events":84,"inherits":88,"string_decoder/":751,"util":80}],740:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// a transform stream is a readable/writable stream where you do
// something with the data.  Sometimes it's called a "filter",
// but that's not a great name for it, since that implies a thing where
// some bits pass through, and others are simply ignored.  (That would
// be a valid example of a transform, of course.)
//
// While the output is causally related to the input, it's not a
// necessarily symmetric or synchronous transformation.  For example,
// a zlib stream might take multiple plain-text writes(), and then
// emit a single compressed chunk some time in the future.
//
// Here's how this works:
//
// The Transform stream has all the aspects of the readable and writable
// stream classes.  When you write(chunk), that calls _write(chunk,cb)
// internally, and returns false if there's a lot of pending writes
// buffered up.  When you call read(), that calls _read(n) until
// there's enough pending readable data buffered up.
//
// In a transform stream, the written data is placed in a buffer.  When
// _read(n) is called, it transforms the queued up data, calling the
// buffered _write cb's as it consumes chunks.  If consuming a single
// written chunk would result in multiple output chunks, then the first
// outputted bit calls the readcb, and subsequent chunks just go into
// the read buffer, and will cause it to emit 'readable' if necessary.
//
// This way, back-pressure is actually determined by the reading side,
// since _read has to be called to start processing a new chunk.  However,
// a pathological inflate type of transform can cause excessive buffering
// here.  For example, imagine a stream where every byte of input is
// interpreted as an integer from 0-255, and then results in that many
// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
// 1kb of data being output.  In this case, you could write a very small
// amount of input, and end up with a very large amount of output.  In
// such a pathological inflating mechanism, there'd be no way to tell
// the system to stop doing the transform.  A single 4MB write could
// cause the system to run out of memory.
//
// However, even in such a pathological case, only a single written chunk
// would be consumed, and then the rest would wait (un-transformed) until
// the results of the previous transformed chunk were consumed.
'use strict';

module.exports = Transform;

var _require$codes = require('../errors').codes,
    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
    ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,
    ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;

var Duplex = require('./_stream_duplex');

require('inherits')(Transform, Duplex);

function afterTransform(er, data) {
  var ts = this._transformState;
  ts.transforming = false;
  var cb = ts.writecb;

  if (cb === null) {
    return this.emit('error', new ERR_MULTIPLE_CALLBACK());
  }

  ts.writechunk = null;
  ts.writecb = null;
  if (data != null) // single equals check for both `null` and `undefined`
    this.push(data);
  cb(er);
  var rs = this._readableState;
  rs.reading = false;

  if (rs.needReadable || rs.length < rs.highWaterMark) {
    this._read(rs.highWaterMark);
  }
}

function Transform(options) {
  if (!(this instanceof Transform)) return new Transform(options);
  Duplex.call(this, options);
  this._transformState = {
    afterTransform: afterTransform.bind(this),
    needTransform: false,
    transforming: false,
    writecb: null,
    writechunk: null,
    writeencoding: null
  }; // start out asking for a readable event once data is transformed.

  this._readableState.needReadable = true; // we have implemented the _read method, and done the other things
  // that Readable wants before the first _read call, so unset the
  // sync guard flag.

  this._readableState.sync = false;

  if (options) {
    if (typeof options.transform === 'function') this._transform = options.transform;
    if (typeof options.flush === 'function') this._flush = options.flush;
  } // When the writable side finishes, then flush out anything remaining.


  this.on('prefinish', prefinish);
}

function prefinish() {
  var _this = this;

  if (typeof this._flush === 'function' && !this._readableState.destroyed) {
    this._flush(function (er, data) {
      done(_this, er, data);
    });
  } else {
    done(this, null, null);
  }
}

Transform.prototype.push = function (chunk, encoding) {
  this._transformState.needTransform = false;
  return Duplex.prototype.push.call(this, chunk, encoding);
}; // This is the part where you do stuff!
// override this function in implementation classes.
// 'chunk' is an input chunk.
//
// Call `push(newChunk)` to pass along transformed output
// to the readable side.  You may call 'push' zero or more times.
//
// Call `cb(err)` when you are done with this chunk.  If you pass
// an error, then that'll put the hurt on the whole operation.  If you
// never call cb(), then you'll never get another chunk.


Transform.prototype._transform = function (chunk, encoding, cb) {
  cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));
};

Transform.prototype._write = function (chunk, encoding, cb) {
  var ts = this._transformState;
  ts.writecb = cb;
  ts.writechunk = chunk;
  ts.writeencoding = encoding;

  if (!ts.transforming) {
    var rs = this._readableState;
    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
  }
}; // Doesn't matter what the args are here.
// _transform does all the work.
// That we got here means that the readable side wants more data.


Transform.prototype._read = function (n) {
  var ts = this._transformState;

  if (ts.writechunk !== null && !ts.transforming) {
    ts.transforming = true;

    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
  } else {
    // mark that we need a transform, so that any data that comes in
    // will get processed, now that we've asked for it.
    ts.needTransform = true;
  }
};

Transform.prototype._destroy = function (err, cb) {
  Duplex.prototype._destroy.call(this, err, function (err2) {
    cb(err2);
  });
};

function done(stream, er, data) {
  if (er) return stream.emit('error', er);
  if (data != null) // single equals check for both `null` and `undefined`
    stream.push(data); // TODO(BridgeAR): Write a test for these two error cases
  // if there's nothing in the write buffer, then that means
  // that nothing more will ever be provided

  if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();
  if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
  return stream.push(null);
}
},{"../errors":736,"./_stream_duplex":737,"inherits":88}],741:[function(require,module,exports){
(function (process,global){(function (){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// A bit simpler than readable streams.
// Implement an async ._write(chunk, encoding, cb), and it'll handle all
// the drain event emission and buffering.
'use strict';

module.exports = Writable;
/* <replacement> */

function WriteReq(chunk, encoding, cb) {
  this.chunk = chunk;
  this.encoding = encoding;
  this.callback = cb;
  this.next = null;
} // It seems a linked list but it is not
// there will be only 2 of these for each stream


function CorkedRequest(state) {
  var _this = this;

  this.next = null;
  this.entry = null;

  this.finish = function () {
    onCorkedFinish(_this, state);
  };
}
/* </replacement> */

/*<replacement>*/


var Duplex;
/*</replacement>*/

Writable.WritableState = WritableState;
/*<replacement>*/

var internalUtil = {
  deprecate: require('util-deprecate')
};
/*</replacement>*/

/*<replacement>*/

var Stream = require('./internal/streams/stream');
/*</replacement>*/


var Buffer = require('buffer').Buffer;

var OurUint8Array = global.Uint8Array || function () {};

function _uint8ArrayToBuffer(chunk) {
  return Buffer.from(chunk);
}

function _isUint8Array(obj) {
  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
}

var destroyImpl = require('./internal/streams/destroy');

var _require = require('./internal/streams/state'),
    getHighWaterMark = _require.getHighWaterMark;

var _require$codes = require('../errors').codes,
    ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
    ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,
    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,
    ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,
    ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,
    ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;

var errorOrDestroy = destroyImpl.errorOrDestroy;

require('inherits')(Writable, Stream);

function nop() {}

function WritableState(options, stream, isDuplex) {
  Duplex = Duplex || require('./_stream_duplex');
  options = options || {}; // Duplex streams are both readable and writable, but share
  // the same options object.
  // However, some cases require setting options to different
  // values for the readable and the writable sides of the duplex stream,
  // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.

  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream
  // contains buffers or objects.

  this.objectMode = !!options.objectMode;
  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false
  // Note: 0 is a valid value, means that we always return false if
  // the entire buffer is not flushed immediately on write()

  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called

  this.finalCalled = false; // drain event flag.

  this.needDrain = false; // at the start of calling end()

  this.ending = false; // when end() has been called, and returned

  this.ended = false; // when 'finish' is emitted

  this.finished = false; // has it been destroyed

  this.destroyed = false; // should we decode strings into buffers before passing to _write?
  // this is here so that some node-core streams can optimize string
  // handling at a lower level.

  var noDecode = options.decodeStrings === false;
  this.decodeStrings = !noDecode; // Crypto is kind of old and crusty.  Historically, its default string
  // encoding is 'binary' so we have to make this configurable.
  // Everything else in the universe uses 'utf8', though.

  this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement
  // of how much we're waiting to get pushed to some underlying
  // socket or file.

  this.length = 0; // a flag to see when we're in the middle of a write.

  this.writing = false; // when true all writes will be buffered until .uncork() call

  this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately,
  // or on a later tick.  We set this to true at first, because any
  // actions that shouldn't happen until "later" should generally also
  // not happen before the first write call.

  this.sync = true; // a flag to know if we're processing previously buffered items, which
  // may call the _write() callback in the same tick, so that we don't
  // end up in an overlapped onwrite situation.

  this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)

  this.onwrite = function (er) {
    onwrite(stream, er);
  }; // the callback that the user supplies to write(chunk,encoding,cb)


  this.writecb = null; // the amount that is being written when _write is called.

  this.writelen = 0;
  this.bufferedRequest = null;
  this.lastBufferedRequest = null; // number of pending user-supplied write callbacks
  // this must be 0 before 'finish' can be emitted

  this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs
  // This is relevant for synchronous Transform streams

  this.prefinished = false; // True if the error was already emitted and should not be thrown again

  this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.

  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end')

  this.autoDestroy = !!options.autoDestroy; // count buffered requests

  this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always
  // one allocated and free to use, and we maintain at most two

  this.corkedRequestsFree = new CorkedRequest(this);
}

WritableState.prototype.getBuffer = function getBuffer() {
  var current = this.bufferedRequest;
  var out = [];

  while (current) {
    out.push(current);
    current = current.next;
  }

  return out;
};

(function () {
  try {
    Object.defineProperty(WritableState.prototype, 'buffer', {
      get: internalUtil.deprecate(function writableStateBufferGetter() {
        return this.getBuffer();
      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
    });
  } catch (_) {}
})(); // Test _writableState for inheritance to account for Duplex streams,
// whose prototype chain only points to Readable.


var realHasInstance;

if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
  realHasInstance = Function.prototype[Symbol.hasInstance];
  Object.defineProperty(Writable, Symbol.hasInstance, {
    value: function value(object) {
      if (realHasInstance.call(this, object)) return true;
      if (this !== Writable) return false;
      return object && object._writableState instanceof WritableState;
    }
  });
} else {
  realHasInstance = function realHasInstance(object) {
    return object instanceof this;
  };
}

function Writable(options) {
  Duplex = Duplex || require('./_stream_duplex'); // Writable ctor is applied to Duplexes, too.
  // `realHasInstance` is necessary because using plain `instanceof`
  // would return false, as no `_writableState` property is attached.
  // Trying to use the custom `instanceof` for Writable here will also break the
  // Node.js LazyTransform implementation, which has a non-trivial getter for
  // `_writableState` that would lead to infinite recursion.
  // Checking for a Stream.Duplex instance is faster here instead of inside
  // the WritableState constructor, at least with V8 6.5

  var isDuplex = this instanceof Duplex;
  if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
  this._writableState = new WritableState(options, this, isDuplex); // legacy.

  this.writable = true;

  if (options) {
    if (typeof options.write === 'function') this._write = options.write;
    if (typeof options.writev === 'function') this._writev = options.writev;
    if (typeof options.destroy === 'function') this._destroy = options.destroy;
    if (typeof options.final === 'function') this._final = options.final;
  }

  Stream.call(this);
} // Otherwise people can pipe Writable streams, which is just wrong.


Writable.prototype.pipe = function () {
  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
};

function writeAfterEnd(stream, cb) {
  var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb

  errorOrDestroy(stream, er);
  process.nextTick(cb, er);
} // Checks that a user-supplied chunk is valid, especially for the particular
// mode the stream is in. Currently this means that `null` is never accepted
// and undefined/non-string values are only allowed in object mode.


function validChunk(stream, state, chunk, cb) {
  var er;

  if (chunk === null) {
    er = new ERR_STREAM_NULL_VALUES();
  } else if (typeof chunk !== 'string' && !state.objectMode) {
    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);
  }

  if (er) {
    errorOrDestroy(stream, er);
    process.nextTick(cb, er);
    return false;
  }

  return true;
}

Writable.prototype.write = function (chunk, encoding, cb) {
  var state = this._writableState;
  var ret = false;

  var isBuf = !state.objectMode && _isUint8Array(chunk);

  if (isBuf && !Buffer.isBuffer(chunk)) {
    chunk = _uint8ArrayToBuffer(chunk);
  }

  if (typeof encoding === 'function') {
    cb = encoding;
    encoding = null;
  }

  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
  if (typeof cb !== 'function') cb = nop;
  if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
    state.pendingcb++;
    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
  }
  return ret;
};

Writable.prototype.cork = function () {
  this._writableState.corked++;
};

Writable.prototype.uncork = function () {
  var state = this._writableState;

  if (state.corked) {
    state.corked--;
    if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
  }
};

Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
  // node::ParseEncoding() requires lower case.
  if (typeof encoding === 'string') encoding = encoding.toLowerCase();
  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);
  this._writableState.defaultEncoding = encoding;
  return this;
};

Object.defineProperty(Writable.prototype, 'writableBuffer', {
  // making it explicit this property is not enumerable
  // because otherwise some prototype manipulation in
  // userland will fail
  enumerable: false,
  get: function get() {
    return this._writableState && this._writableState.getBuffer();
  }
});

function decodeChunk(state, chunk, encoding) {
  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
    chunk = Buffer.from(chunk, encoding);
  }

  return chunk;
}

Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
  // making it explicit this property is not enumerable
  // because otherwise some prototype manipulation in
  // userland will fail
  enumerable: false,
  get: function get() {
    return this._writableState.highWaterMark;
  }
}); // if we're already writing something, then just put this
// in the queue, and wait our turn.  Otherwise, call _write
// If we return false, then we need a drain event, so set that flag.

function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
  if (!isBuf) {
    var newChunk = decodeChunk(state, chunk, encoding);

    if (chunk !== newChunk) {
      isBuf = true;
      encoding = 'buffer';
      chunk = newChunk;
    }
  }

  var len = state.objectMode ? 1 : chunk.length;
  state.length += len;
  var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.

  if (!ret) state.needDrain = true;

  if (state.writing || state.corked) {
    var last = state.lastBufferedRequest;
    state.lastBufferedRequest = {
      chunk: chunk,
      encoding: encoding,
      isBuf: isBuf,
      callback: cb,
      next: null
    };

    if (last) {
      last.next = state.lastBufferedRequest;
    } else {
      state.bufferedRequest = state.lastBufferedRequest;
    }

    state.bufferedRequestCount += 1;
  } else {
    doWrite(stream, state, false, len, chunk, encoding, cb);
  }

  return ret;
}

function doWrite(stream, state, writev, len, chunk, encoding, cb) {
  state.writelen = len;
  state.writecb = cb;
  state.writing = true;
  state.sync = true;
  if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
  state.sync = false;
}

function onwriteError(stream, state, sync, er, cb) {
  --state.pendingcb;

  if (sync) {
    // defer the callback if we are being called synchronously
    // to avoid piling up things on the stack
    process.nextTick(cb, er); // this can emit finish, and it will always happen
    // after error

    process.nextTick(finishMaybe, stream, state);
    stream._writableState.errorEmitted = true;
    errorOrDestroy(stream, er);
  } else {
    // the caller expect this to happen before if
    // it is async
    cb(er);
    stream._writableState.errorEmitted = true;
    errorOrDestroy(stream, er); // this can emit finish, but finish must
    // always follow error

    finishMaybe(stream, state);
  }
}

function onwriteStateUpdate(state) {
  state.writing = false;
  state.writecb = null;
  state.length -= state.writelen;
  state.writelen = 0;
}

function onwrite(stream, er) {
  var state = stream._writableState;
  var sync = state.sync;
  var cb = state.writecb;
  if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();
  onwriteStateUpdate(state);
  if (er) onwriteError(stream, state, sync, er, cb);else {
    // Check if we're actually ready to finish, but don't emit yet
    var finished = needFinish(state) || stream.destroyed;

    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
      clearBuffer(stream, state);
    }

    if (sync) {
      process.nextTick(afterWrite, stream, state, finished, cb);
    } else {
      afterWrite(stream, state, finished, cb);
    }
  }
}

function afterWrite(stream, state, finished, cb) {
  if (!finished) onwriteDrain(stream, state);
  state.pendingcb--;
  cb();
  finishMaybe(stream, state);
} // Must force callback to be called on nextTick, so that we don't
// emit 'drain' before the write() consumer gets the 'false' return
// value, and has a chance to attach a 'drain' listener.


function onwriteDrain(stream, state) {
  if (state.length === 0 && state.needDrain) {
    state.needDrain = false;
    stream.emit('drain');
  }
} // if there's something in the buffer waiting, then process it


function clearBuffer(stream, state) {
  state.bufferProcessing = true;
  var entry = state.bufferedRequest;

  if (stream._writev && entry && entry.next) {
    // Fast case, write everything using _writev()
    var l = state.bufferedRequestCount;
    var buffer = new Array(l);
    var holder = state.corkedRequestsFree;
    holder.entry = entry;
    var count = 0;
    var allBuffers = true;

    while (entry) {
      buffer[count] = entry;
      if (!entry.isBuf) allBuffers = false;
      entry = entry.next;
      count += 1;
    }

    buffer.allBuffers = allBuffers;
    doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time
    // as the hot path ends with doWrite

    state.pendingcb++;
    state.lastBufferedRequest = null;

    if (holder.next) {
      state.corkedRequestsFree = holder.next;
      holder.next = null;
    } else {
      state.corkedRequestsFree = new CorkedRequest(state);
    }

    state.bufferedRequestCount = 0;
  } else {
    // Slow case, write chunks one-by-one
    while (entry) {
      var chunk = entry.chunk;
      var encoding = entry.encoding;
      var cb = entry.callback;
      var len = state.objectMode ? 1 : chunk.length;
      doWrite(stream, state, false, len, chunk, encoding, cb);
      entry = entry.next;
      state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then
      // it means that we need to wait until it does.
      // also, that means that the chunk and cb are currently
      // being processed, so move the buffer counter past them.

      if (state.writing) {
        break;
      }
    }

    if (entry === null) state.lastBufferedRequest = null;
  }

  state.bufferedRequest = entry;
  state.bufferProcessing = false;
}

Writable.prototype._write = function (chunk, encoding, cb) {
  cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));
};

Writable.prototype._writev = null;

Writable.prototype.end = function (chunk, encoding, cb) {
  var state = this._writableState;

  if (typeof chunk === 'function') {
    cb = chunk;
    chunk = null;
    encoding = null;
  } else if (typeof encoding === 'function') {
    cb = encoding;
    encoding = null;
  }

  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks

  if (state.corked) {
    state.corked = 1;
    this.uncork();
  } // ignore unnecessary end() calls.


  if (!state.ending) endWritable(this, state, cb);
  return this;
};

Object.defineProperty(Writable.prototype, 'writableLength', {
  // making it explicit this property is not enumerable
  // because otherwise some prototype manipulation in
  // userland will fail
  enumerable: false,
  get: function get() {
    return this._writableState.length;
  }
});

function needFinish(state) {
  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
}

function callFinal(stream, state) {
  stream._final(function (err) {
    state.pendingcb--;

    if (err) {
      errorOrDestroy(stream, err);
    }

    state.prefinished = true;
    stream.emit('prefinish');
    finishMaybe(stream, state);
  });
}

function prefinish(stream, state) {
  if (!state.prefinished && !state.finalCalled) {
    if (typeof stream._final === 'function' && !state.destroyed) {
      state.pendingcb++;
      state.finalCalled = true;
      process.nextTick(callFinal, stream, state);
    } else {
      state.prefinished = true;
      stream.emit('prefinish');
    }
  }
}

function finishMaybe(stream, state) {
  var need = needFinish(state);

  if (need) {
    prefinish(stream, state);

    if (state.pendingcb === 0) {
      state.finished = true;
      stream.emit('finish');

      if (state.autoDestroy) {
        // In case of duplex streams we need a way to detect
        // if the readable side is ready for autoDestroy as well
        var rState = stream._readableState;

        if (!rState || rState.autoDestroy && rState.endEmitted) {
          stream.destroy();
        }
      }
    }
  }

  return need;
}

function endWritable(stream, state, cb) {
  state.ending = true;
  finishMaybe(stream, state);

  if (cb) {
    if (state.finished) process.nextTick(cb);else stream.once('finish', cb);
  }

  state.ended = true;
  stream.writable = false;
}

function onCorkedFinish(corkReq, state, err) {
  var entry = corkReq.entry;
  corkReq.entry = null;

  while (entry) {
    var cb = entry.callback;
    state.pendingcb--;
    cb(err);
    entry = entry.next;
  } // reuse the free corkReq.


  state.corkedRequestsFree.next = corkReq;
}

Object.defineProperty(Writable.prototype, 'destroyed', {
  // making it explicit this property is not enumerable
  // because otherwise some prototype manipulation in
  // userland will fail
  enumerable: false,
  get: function get() {
    if (this._writableState === undefined) {
      return false;
    }

    return this._writableState.destroyed;
  },
  set: function set(value) {
    // we ignore the value if the stream
    // has not been initialized yet
    if (!this._writableState) {
      return;
    } // backward compatibility, the user is explicitly
    // managing destroyed


    this._writableState.destroyed = value;
  }
});
Writable.prototype.destroy = destroyImpl.destroy;
Writable.prototype._undestroy = destroyImpl.undestroy;

Writable.prototype._destroy = function (err, cb) {
  cb(err);
};
}).call(this)}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{"../errors":736,"./_stream_duplex":737,"./internal/streams/destroy":744,"./internal/streams/state":748,"./internal/streams/stream":749,"_process":714,"buffer":81,"inherits":88,"util-deprecate":755}],742:[function(require,module,exports){
(function (process){(function (){
'use strict';

var _Object$setPrototypeO;

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

var finished = require('./end-of-stream');

var kLastResolve = Symbol('lastResolve');
var kLastReject = Symbol('lastReject');
var kError = Symbol('error');
var kEnded = Symbol('ended');
var kLastPromise = Symbol('lastPromise');
var kHandlePromise = Symbol('handlePromise');
var kStream = Symbol('stream');

function createIterResult(value, done) {
  return {
    value: value,
    done: done
  };
}

function readAndResolve(iter) {
  var resolve = iter[kLastResolve];

  if (resolve !== null) {
    var data = iter[kStream].read(); // we defer if data is null
    // we can be expecting either 'end' or
    // 'error'

    if (data !== null) {
      iter[kLastPromise] = null;
      iter[kLastResolve] = null;
      iter[kLastReject] = null;
      resolve(createIterResult(data, false));
    }
  }
}

function onReadable(iter) {
  // we wait for the next tick, because it might
  // emit an error with process.nextTick
  process.nextTick(readAndResolve, iter);
}

function wrapForNext(lastPromise, iter) {
  return function (resolve, reject) {
    lastPromise.then(function () {
      if (iter[kEnded]) {
        resolve(createIterResult(undefined, true));
        return;
      }

      iter[kHandlePromise](resolve, reject);
    }, reject);
  };
}

var AsyncIteratorPrototype = Object.getPrototypeOf(function () {});
var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
  get stream() {
    return this[kStream];
  },

  next: function next() {
    var _this = this;

    // if we have detected an error in the meanwhile
    // reject straight away
    var error = this[kError];

    if (error !== null) {
      return Promise.reject(error);
    }

    if (this[kEnded]) {
      return Promise.resolve(createIterResult(undefined, true));
    }

    if (this[kStream].destroyed) {
      // We need to defer via nextTick because if .destroy(err) is
      // called, the error will be emitted via nextTick, and
      // we cannot guarantee that there is no error lingering around
      // waiting to be emitted.
      return new Promise(function (resolve, reject) {
        process.nextTick(function () {
          if (_this[kError]) {
            reject(_this[kError]);
          } else {
            resolve(createIterResult(undefined, true));
          }
        });
      });
    } // if we have multiple next() calls
    // we will wait for the previous Promise to finish
    // this logic is optimized to support for await loops,
    // where next() is only called once at a time


    var lastPromise = this[kLastPromise];
    var promise;

    if (lastPromise) {
      promise = new Promise(wrapForNext(lastPromise, this));
    } else {
      // fast path needed to support multiple this.push()
      // without triggering the next() queue
      var data = this[kStream].read();

      if (data !== null) {
        return Promise.resolve(createIterResult(data, false));
      }

      promise = new Promise(this[kHandlePromise]);
    }

    this[kLastPromise] = promise;
    return promise;
  }
}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {
  return this;
}), _defineProperty(_Object$setPrototypeO, "return", function _return() {
  var _this2 = this;

  // destroy(err, cb) is a private API
  // we can guarantee we have that here, because we control the
  // Readable class this is attached to
  return new Promise(function (resolve, reject) {
    _this2[kStream].destroy(null, function (err) {
      if (err) {
        reject(err);
        return;
      }

      resolve(createIterResult(undefined, true));
    });
  });
}), _Object$setPrototypeO), AsyncIteratorPrototype);

var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {
  var _Object$create;

  var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
    value: stream,
    writable: true
  }), _defineProperty(_Object$create, kLastResolve, {
    value: null,
    writable: true
  }), _defineProperty(_Object$create, kLastReject, {
    value: null,
    writable: true
  }), _defineProperty(_Object$create, kError, {
    value: null,
    writable: true
  }), _defineProperty(_Object$create, kEnded, {
    value: stream._readableState.endEmitted,
    writable: true
  }), _defineProperty(_Object$create, kHandlePromise, {
    value: function value(resolve, reject) {
      var data = iterator[kStream].read();

      if (data) {
        iterator[kLastPromise] = null;
        iterator[kLastResolve] = null;
        iterator[kLastReject] = null;
        resolve(createIterResult(data, false));
      } else {
        iterator[kLastResolve] = resolve;
        iterator[kLastReject] = reject;
      }
    },
    writable: true
  }), _Object$create));
  iterator[kLastPromise] = null;
  finished(stream, function (err) {
    if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
      var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise
      // returned by next() and store the error

      if (reject !== null) {
        iterator[kLastPromise] = null;
        iterator[kLastResolve] = null;
        iterator[kLastReject] = null;
        reject(err);
      }

      iterator[kError] = err;
      return;
    }

    var resolve = iterator[kLastResolve];

    if (resolve !== null) {
      iterator[kLastPromise] = null;
      iterator[kLastResolve] = null;
      iterator[kLastReject] = null;
      resolve(createIterResult(undefined, true));
    }

    iterator[kEnded] = true;
  });
  stream.on('readable', onReadable.bind(null, iterator));
  return iterator;
};

module.exports = createReadableStreamAsyncIterator;
}).call(this)}).call(this,require('_process'))

},{"./end-of-stream":745,"_process":714}],743:[function(require,module,exports){
'use strict';

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

var _require = require('buffer'),
    Buffer = _require.Buffer;

var _require2 = require('util'),
    inspect = _require2.inspect;

var custom = inspect && inspect.custom || 'inspect';

function copyBuffer(src, target, offset) {
  Buffer.prototype.copy.call(src, target, offset);
}

module.exports =
/*#__PURE__*/
function () {
  function BufferList() {
    _classCallCheck(this, BufferList);

    this.head = null;
    this.tail = null;
    this.length = 0;
  }

  _createClass(BufferList, [{
    key: "push",
    value: function push(v) {
      var entry = {
        data: v,
        next: null
      };
      if (this.length > 0) this.tail.next = entry;else this.head = entry;
      this.tail = entry;
      ++this.length;
    }
  }, {
    key: "unshift",
    value: function unshift(v) {
      var entry = {
        data: v,
        next: this.head
      };
      if (this.length === 0) this.tail = entry;
      this.head = entry;
      ++this.length;
    }
  }, {
    key: "shift",
    value: function shift() {
      if (this.length === 0) return;
      var ret = this.head.data;
      if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
      --this.length;
      return ret;
    }
  }, {
    key: "clear",
    value: function clear() {
      this.head = this.tail = null;
      this.length = 0;
    }
  }, {
    key: "join",
    value: function join(s) {
      if (this.length === 0) return '';
      var p = this.head;
      var ret = '' + p.data;

      while (p = p.next) {
        ret += s + p.data;
      }

      return ret;
    }
  }, {
    key: "concat",
    value: function concat(n) {
      if (this.length === 0) return Buffer.alloc(0);
      var ret = Buffer.allocUnsafe(n >>> 0);
      var p = this.head;
      var i = 0;

      while (p) {
        copyBuffer(p.data, ret, i);
        i += p.data.length;
        p = p.next;
      }

      return ret;
    } // Consumes a specified amount of bytes or characters from the buffered data.

  }, {
    key: "consume",
    value: function consume(n, hasStrings) {
      var ret;

      if (n < this.head.data.length) {
        // `slice` is the same for buffers and strings.
        ret = this.head.data.slice(0, n);
        this.head.data = this.head.data.slice(n);
      } else if (n === this.head.data.length) {
        // First chunk is a perfect match.
        ret = this.shift();
      } else {
        // Result spans more than one buffer.
        ret = hasStrings ? this._getString(n) : this._getBuffer(n);
      }

      return ret;
    }
  }, {
    key: "first",
    value: function first() {
      return this.head.data;
    } // Consumes a specified amount of characters from the buffered data.

  }, {
    key: "_getString",
    value: function _getString(n) {
      var p = this.head;
      var c = 1;
      var ret = p.data;
      n -= ret.length;

      while (p = p.next) {
        var str = p.data;
        var nb = n > str.length ? str.length : n;
        if (nb === str.length) ret += str;else ret += str.slice(0, n);
        n -= nb;

        if (n === 0) {
          if (nb === str.length) {
            ++c;
            if (p.next) this.head = p.next;else this.head = this.tail = null;
          } else {
            this.head = p;
            p.data = str.slice(nb);
          }

          break;
        }

        ++c;
      }

      this.length -= c;
      return ret;
    } // Consumes a specified amount of bytes from the buffered data.

  }, {
    key: "_getBuffer",
    value: function _getBuffer(n) {
      var ret = Buffer.allocUnsafe(n);
      var p = this.head;
      var c = 1;
      p.data.copy(ret);
      n -= p.data.length;

      while (p = p.next) {
        var buf = p.data;
        var nb = n > buf.length ? buf.length : n;
        buf.copy(ret, ret.length - n, 0, nb);
        n -= nb;

        if (n === 0) {
          if (nb === buf.length) {
            ++c;
            if (p.next) this.head = p.next;else this.head = this.tail = null;
          } else {
            this.head = p;
            p.data = buf.slice(nb);
          }

          break;
        }

        ++c;
      }

      this.length -= c;
      return ret;
    } // Make sure the linked list only shows the minimal necessary information.

  }, {
    key: custom,
    value: function value(_, options) {
      return inspect(this, _objectSpread({}, options, {
        // Only inspect one level.
        depth: 0,
        // It should not recurse.
        customInspect: false
      }));
    }
  }]);

  return BufferList;
}();
},{"buffer":81,"util":80}],744:[function(require,module,exports){
(function (process){(function (){
'use strict'; // undocumented cb() API, needed for core, not for public API

function destroy(err, cb) {
  var _this = this;

  var readableDestroyed = this._readableState && this._readableState.destroyed;
  var writableDestroyed = this._writableState && this._writableState.destroyed;

  if (readableDestroyed || writableDestroyed) {
    if (cb) {
      cb(err);
    } else if (err) {
      if (!this._writableState) {
        process.nextTick(emitErrorNT, this, err);
      } else if (!this._writableState.errorEmitted) {
        this._writableState.errorEmitted = true;
        process.nextTick(emitErrorNT, this, err);
      }
    }

    return this;
  } // we set destroyed to true before firing error callbacks in order
  // to make it re-entrance safe in case destroy() is called within callbacks


  if (this._readableState) {
    this._readableState.destroyed = true;
  } // if this is a duplex stream mark the writable part as destroyed as well


  if (this._writableState) {
    this._writableState.destroyed = true;
  }

  this._destroy(err || null, function (err) {
    if (!cb && err) {
      if (!_this._writableState) {
        process.nextTick(emitErrorAndCloseNT, _this, err);
      } else if (!_this._writableState.errorEmitted) {
        _this._writableState.errorEmitted = true;
        process.nextTick(emitErrorAndCloseNT, _this, err);
      } else {
        process.nextTick(emitCloseNT, _this);
      }
    } else if (cb) {
      process.nextTick(emitCloseNT, _this);
      cb(err);
    } else {
      process.nextTick(emitCloseNT, _this);
    }
  });

  return this;
}

function emitErrorAndCloseNT(self, err) {
  emitErrorNT(self, err);
  emitCloseNT(self);
}

function emitCloseNT(self) {
  if (self._writableState && !self._writableState.emitClose) return;
  if (self._readableState && !self._readableState.emitClose) return;
  self.emit('close');
}

function undestroy() {
  if (this._readableState) {
    this._readableState.destroyed = false;
    this._readableState.reading = false;
    this._readableState.ended = false;
    this._readableState.endEmitted = false;
  }

  if (this._writableState) {
    this._writableState.destroyed = false;
    this._writableState.ended = false;
    this._writableState.ending = false;
    this._writableState.finalCalled = false;
    this._writableState.prefinished = false;
    this._writableState.finished = false;
    this._writableState.errorEmitted = false;
  }
}

function emitErrorNT(self, err) {
  self.emit('error', err);
}

function errorOrDestroy(stream, err) {
  // We have tests that rely on errors being emitted
  // in the same tick, so changing this is semver major.
  // For now when you opt-in to autoDestroy we allow
  // the error to be emitted nextTick. In a future
  // semver major update we should change the default to this.
  var rState = stream._readableState;
  var wState = stream._writableState;
  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
}

module.exports = {
  destroy: destroy,
  undestroy: undestroy,
  errorOrDestroy: errorOrDestroy
};
}).call(this)}).call(this,require('_process'))

},{"_process":714}],745:[function(require,module,exports){
// Ported from https://github.com/mafintosh/end-of-stream with
// permission from the author, Mathias Buus (@mafintosh).
'use strict';

var ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;

function once(callback) {
  var called = false;
  return function () {
    if (called) return;
    called = true;

    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    callback.apply(this, args);
  };
}

function noop() {}

function isRequest(stream) {
  return stream.setHeader && typeof stream.abort === 'function';
}

function eos(stream, opts, callback) {
  if (typeof opts === 'function') return eos(stream, null, opts);
  if (!opts) opts = {};
  callback = once(callback || noop);
  var readable = opts.readable || opts.readable !== false && stream.readable;
  var writable = opts.writable || opts.writable !== false && stream.writable;

  var onlegacyfinish = function onlegacyfinish() {
    if (!stream.writable) onfinish();
  };

  var writableEnded = stream._writableState && stream._writableState.finished;

  var onfinish = function onfinish() {
    writable = false;
    writableEnded = true;
    if (!readable) callback.call(stream);
  };

  var readableEnded = stream._readableState && stream._readableState.endEmitted;

  var onend = function onend() {
    readable = false;
    readableEnded = true;
    if (!writable) callback.call(stream);
  };

  var onerror = function onerror(err) {
    callback.call(stream, err);
  };

  var onclose = function onclose() {
    var err;

    if (readable && !readableEnded) {
      if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
      return callback.call(stream, err);
    }

    if (writable && !writableEnded) {
      if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
      return callback.call(stream, err);
    }
  };

  var onrequest = function onrequest() {
    stream.req.on('finish', onfinish);
  };

  if (isRequest(stream)) {
    stream.on('complete', onfinish);
    stream.on('abort', onclose);
    if (stream.req) onrequest();else stream.on('request', onrequest);
  } else if (writable && !stream._writableState) {
    // legacy streams
    stream.on('end', onlegacyfinish);
    stream.on('close', onlegacyfinish);
  }

  stream.on('end', onend);
  stream.on('finish', onfinish);
  if (opts.error !== false) stream.on('error', onerror);
  stream.on('close', onclose);
  return function () {
    stream.removeListener('complete', onfinish);
    stream.removeListener('abort', onclose);
    stream.removeListener('request', onrequest);
    if (stream.req) stream.req.removeListener('finish', onfinish);
    stream.removeListener('end', onlegacyfinish);
    stream.removeListener('close', onlegacyfinish);
    stream.removeListener('finish', onfinish);
    stream.removeListener('end', onend);
    stream.removeListener('error', onerror);
    stream.removeListener('close', onclose);
  };
}

module.exports = eos;
},{"../../../errors":736}],746:[function(require,module,exports){
module.exports = function () {
  throw new Error('Readable.from is not available in the browser')
};

},{}],747:[function(require,module,exports){
// Ported from https://github.com/mafintosh/pump with
// permission from the author, Mathias Buus (@mafintosh).
'use strict';

var eos;

function once(callback) {
  var called = false;
  return function () {
    if (called) return;
    called = true;
    callback.apply(void 0, arguments);
  };
}

var _require$codes = require('../../../errors').codes,
    ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;

function noop(err) {
  // Rethrow the error if it exists to avoid swallowing it
  if (err) throw err;
}

function isRequest(stream) {
  return stream.setHeader && typeof stream.abort === 'function';
}

function destroyer(stream, reading, writing, callback) {
  callback = once(callback);
  var closed = false;
  stream.on('close', function () {
    closed = true;
  });
  if (eos === undefined) eos = require('./end-of-stream');
  eos(stream, {
    readable: reading,
    writable: writing
  }, function (err) {
    if (err) return callback(err);
    closed = true;
    callback();
  });
  var destroyed = false;
  return function (err) {
    if (closed) return;
    if (destroyed) return;
    destroyed = true; // request.destroy just do .end - .abort is what we want

    if (isRequest(stream)) return stream.abort();
    if (typeof stream.destroy === 'function') return stream.destroy();
    callback(err || new ERR_STREAM_DESTROYED('pipe'));
  };
}

function call(fn) {
  fn();
}

function pipe(from, to) {
  return from.pipe(to);
}

function popCallback(streams) {
  if (!streams.length) return noop;
  if (typeof streams[streams.length - 1] !== 'function') return noop;
  return streams.pop();
}

function pipeline() {
  for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
    streams[_key] = arguments[_key];
  }

  var callback = popCallback(streams);
  if (Array.isArray(streams[0])) streams = streams[0];

  if (streams.length < 2) {
    throw new ERR_MISSING_ARGS('streams');
  }

  var error;
  var destroys = streams.map(function (stream, i) {
    var reading = i < streams.length - 1;
    var writing = i > 0;
    return destroyer(stream, reading, writing, function (err) {
      if (!error) error = err;
      if (err) destroys.forEach(call);
      if (reading) return;
      destroys.forEach(call);
      callback(error);
    });
  });
  return streams.reduce(pipe);
}

module.exports = pipeline;
},{"../../../errors":736,"./end-of-stream":745}],748:[function(require,module,exports){
'use strict';

var ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;

function highWaterMarkFrom(options, isDuplex, duplexKey) {
  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
}

function getHighWaterMark(state, options, duplexKey, isDuplex) {
  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);

  if (hwm != null) {
    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
      var name = isDuplex ? duplexKey : 'highWaterMark';
      throw new ERR_INVALID_OPT_VALUE(name, hwm);
    }

    return Math.floor(hwm);
  } // Default value


  return state.objectMode ? 16 : 16 * 1024;
}

module.exports = {
  getHighWaterMark: getHighWaterMark
};
},{"../../../errors":736}],749:[function(require,module,exports){
module.exports = require('events').EventEmitter;

},{"events":84}],750:[function(require,module,exports){
exports = module.exports = require('./lib/_stream_readable.js');
exports.Stream = exports;
exports.Readable = exports;
exports.Writable = require('./lib/_stream_writable.js');
exports.Duplex = require('./lib/_stream_duplex.js');
exports.Transform = require('./lib/_stream_transform.js');
exports.PassThrough = require('./lib/_stream_passthrough.js');
exports.finished = require('./lib/internal/streams/end-of-stream.js');
exports.pipeline = require('./lib/internal/streams/pipeline.js');

},{"./lib/_stream_duplex.js":737,"./lib/_stream_passthrough.js":738,"./lib/_stream_readable.js":739,"./lib/_stream_transform.js":740,"./lib/_stream_writable.js":741,"./lib/internal/streams/end-of-stream.js":745,"./lib/internal/streams/pipeline.js":747}],751:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

'use strict';

/*<replacement>*/

var Buffer = require('safe-buffer').Buffer;
/*</replacement>*/

var isEncoding = Buffer.isEncoding || function (encoding) {
  encoding = '' + encoding;
  switch (encoding && encoding.toLowerCase()) {
    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
      return true;
    default:
      return false;
  }
};

function _normalizeEncoding(enc) {
  if (!enc) return 'utf8';
  var retried;
  while (true) {
    switch (enc) {
      case 'utf8':
      case 'utf-8':
        return 'utf8';
      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return 'utf16le';
      case 'latin1':
      case 'binary':
        return 'latin1';
      case 'base64':
      case 'ascii':
      case 'hex':
        return enc;
      default:
        if (retried) return; // undefined
        enc = ('' + enc).toLowerCase();
        retried = true;
    }
  }
};

// Do not cache `Buffer.isEncoding` when checking encoding names as some
// modules monkey-patch it to support additional encodings
function normalizeEncoding(enc) {
  var nenc = _normalizeEncoding(enc);
  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
  return nenc || enc;
}

// StringDecoder provides an interface for efficiently splitting a series of
// buffers into a series of JS strings without breaking apart multi-byte
// characters.
exports.StringDecoder = StringDecoder;
function StringDecoder(encoding) {
  this.encoding = normalizeEncoding(encoding);
  var nb;
  switch (this.encoding) {
    case 'utf16le':
      this.text = utf16Text;
      this.end = utf16End;
      nb = 4;
      break;
    case 'utf8':
      this.fillLast = utf8FillLast;
      nb = 4;
      break;
    case 'base64':
      this.text = base64Text;
      this.end = base64End;
      nb = 3;
      break;
    default:
      this.write = simpleWrite;
      this.end = simpleEnd;
      return;
  }
  this.lastNeed = 0;
  this.lastTotal = 0;
  this.lastChar = Buffer.allocUnsafe(nb);
}

StringDecoder.prototype.write = function (buf) {
  if (buf.length === 0) return '';
  var r;
  var i;
  if (this.lastNeed) {
    r = this.fillLast(buf);
    if (r === undefined) return '';
    i = this.lastNeed;
    this.lastNeed = 0;
  } else {
    i = 0;
  }
  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
  return r || '';
};

StringDecoder.prototype.end = utf8End;

// Returns only complete characters in a Buffer
StringDecoder.prototype.text = utf8Text;

// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
StringDecoder.prototype.fillLast = function (buf) {
  if (this.lastNeed <= buf.length) {
    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
  }
  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
  this.lastNeed -= buf.length;
};

// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
// continuation byte. If an invalid byte is detected, -2 is returned.
function utf8CheckByte(byte) {
  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
  return byte >> 6 === 0x02 ? -1 : -2;
}

// Checks at most 3 bytes at the end of a Buffer in order to detect an
// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
// needed to complete the UTF-8 character (if applicable) are returned.
function utf8CheckIncomplete(self, buf, i) {
  var j = buf.length - 1;
  if (j < i) return 0;
  var nb = utf8CheckByte(buf[j]);
  if (nb >= 0) {
    if (nb > 0) self.lastNeed = nb - 1;
    return nb;
  }
  if (--j < i || nb === -2) return 0;
  nb = utf8CheckByte(buf[j]);
  if (nb >= 0) {
    if (nb > 0) self.lastNeed = nb - 2;
    return nb;
  }
  if (--j < i || nb === -2) return 0;
  nb = utf8CheckByte(buf[j]);
  if (nb >= 0) {
    if (nb > 0) {
      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
    }
    return nb;
  }
  return 0;
}

// Validates as many continuation bytes for a multi-byte UTF-8 character as
// needed or are available. If we see a non-continuation byte where we expect
// one, we "replace" the validated continuation bytes we've seen so far with
// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
// behavior. The continuation byte check is included three times in the case
// where all of the continuation bytes for a character exist in the same buffer.
// It is also done this way as a slight performance increase instead of using a
// loop.
function utf8CheckExtraBytes(self, buf, p) {
  if ((buf[0] & 0xC0) !== 0x80) {
    self.lastNeed = 0;
    return '\ufffd';
  }
  if (self.lastNeed > 1 && buf.length > 1) {
    if ((buf[1] & 0xC0) !== 0x80) {
      self.lastNeed = 1;
      return '\ufffd';
    }
    if (self.lastNeed > 2 && buf.length > 2) {
      if ((buf[2] & 0xC0) !== 0x80) {
        self.lastNeed = 2;
        return '\ufffd';
      }
    }
  }
}

// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
function utf8FillLast(buf) {
  var p = this.lastTotal - this.lastNeed;
  var r = utf8CheckExtraBytes(this, buf, p);
  if (r !== undefined) return r;
  if (this.lastNeed <= buf.length) {
    buf.copy(this.lastChar, p, 0, this.lastNeed);
    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
  }
  buf.copy(this.lastChar, p, 0, buf.length);
  this.lastNeed -= buf.length;
}

// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
// partial character, the character's bytes are buffered until the required
// number of bytes are available.
function utf8Text(buf, i) {
  var total = utf8CheckIncomplete(this, buf, i);
  if (!this.lastNeed) return buf.toString('utf8', i);
  this.lastTotal = total;
  var end = buf.length - (total - this.lastNeed);
  buf.copy(this.lastChar, 0, end);
  return buf.toString('utf8', i, end);
}

// For UTF-8, a replacement character is added when ending on a partial
// character.
function utf8End(buf) {
  var r = buf && buf.length ? this.write(buf) : '';
  if (this.lastNeed) return r + '\ufffd';
  return r;
}

// UTF-16LE typically needs two bytes per character, but even if we have an even
// number of bytes available, we need to check if we end on a leading/high
// surrogate. In that case, we need to wait for the next two bytes in order to
// decode the last character properly.
function utf16Text(buf, i) {
  if ((buf.length - i) % 2 === 0) {
    var r = buf.toString('utf16le', i);
    if (r) {
      var c = r.charCodeAt(r.length - 1);
      if (c >= 0xD800 && c <= 0xDBFF) {
        this.lastNeed = 2;
        this.lastTotal = 4;
        this.lastChar[0] = buf[buf.length - 2];
        this.lastChar[1] = buf[buf.length - 1];
        return r.slice(0, -1);
      }
    }
    return r;
  }
  this.lastNeed = 1;
  this.lastTotal = 2;
  this.lastChar[0] = buf[buf.length - 1];
  return buf.toString('utf16le', i, buf.length - 1);
}

// For UTF-16LE we do not explicitly append special replacement characters if we
// end on a partial character, we simply let v8 handle that.
function utf16End(buf) {
  var r = buf && buf.length ? this.write(buf) : '';
  if (this.lastNeed) {
    var end = this.lastTotal - this.lastNeed;
    return r + this.lastChar.toString('utf16le', 0, end);
  }
  return r;
}

function base64Text(buf, i) {
  var n = (buf.length - i) % 3;
  if (n === 0) return buf.toString('base64', i);
  this.lastNeed = 3 - n;
  this.lastTotal = 3;
  if (n === 1) {
    this.lastChar[0] = buf[buf.length - 1];
  } else {
    this.lastChar[0] = buf[buf.length - 2];
    this.lastChar[1] = buf[buf.length - 1];
  }
  return buf.toString('base64', i, buf.length - n);
}

function base64End(buf) {
  var r = buf && buf.length ? this.write(buf) : '';
  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
  return r;
}

// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
function simpleWrite(buf) {
  return buf.toString(this.encoding);
}

function simpleEnd(buf) {
  return buf && buf.length ? this.write(buf) : '';
}
},{"safe-buffer":731}],752:[function(require,module,exports){
(function (setImmediate,clearImmediate){(function (){
var nextTick = require('process/browser.js').nextTick;
var apply = Function.prototype.apply;
var slice = Array.prototype.slice;
var immediateIds = {};
var nextImmediateId = 0;

// DOM APIs, for completeness

exports.setTimeout = function() {
  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
};
exports.setInterval = function() {
  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
};
exports.clearTimeout =
exports.clearInterval = function(timeout) { timeout.close(); };

function Timeout(id, clearFn) {
  this._id = id;
  this._clearFn = clearFn;
}
Timeout.prototype.unref = Timeout.prototype.ref = function() {};
Timeout.prototype.close = function() {
  this._clearFn.call(window, this._id);
};

// Does not start the time, just sets up the members needed.
exports.enroll = function(item, msecs) {
  clearTimeout(item._idleTimeoutId);
  item._idleTimeout = msecs;
};

exports.unenroll = function(item) {
  clearTimeout(item._idleTimeoutId);
  item._idleTimeout = -1;
};

exports._unrefActive = exports.active = function(item) {
  clearTimeout(item._idleTimeoutId);

  var msecs = item._idleTimeout;
  if (msecs >= 0) {
    item._idleTimeoutId = setTimeout(function onTimeout() {
      if (item._onTimeout)
        item._onTimeout();
    }, msecs);
  }
};

// That's not how node.js implements it but the exposed api is the same.
exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) {
  var id = nextImmediateId++;
  var args = arguments.length < 2 ? false : slice.call(arguments, 1);

  immediateIds[id] = true;

  nextTick(function onNextTick() {
    if (immediateIds[id]) {
      // fn.call() is faster so we optimize for the common use-case
      // @see http://jsperf.com/call-apply-segu
      if (args) {
        fn.apply(null, args);
      } else {
        fn.call(null);
      }
      // Prevent ids from leaking
      exports.clearImmediate(id);
    }
  });

  return id;
};

exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) {
  delete immediateIds[id];
};
}).call(this)}).call(this,require("timers").setImmediate,require("timers").clearImmediate)

},{"process/browser.js":714,"timers":752}],753:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

'use strict';

var punycode = require('punycode');
var util = require('./util');

exports.parse = urlParse;
exports.resolve = urlResolve;
exports.resolveObject = urlResolveObject;
exports.format = urlFormat;

exports.Url = Url;

function Url() {
  this.protocol = null;
  this.slashes = null;
  this.auth = null;
  this.host = null;
  this.port = null;
  this.hostname = null;
  this.hash = null;
  this.search = null;
  this.query = null;
  this.pathname = null;
  this.path = null;
  this.href = null;
}

// Reference: RFC 3986, RFC 1808, RFC 2396

// define these here so at least they only have to be
// compiled once on the first module load.
var protocolPattern = /^([a-z0-9.+-]+:)/i,
    portPattern = /:[0-9]*$/,

    // Special case for a simple path URL
    simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,

    // RFC 2396: characters reserved for delimiting URLs.
    // We actually just auto-escape these.
    delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],

    // RFC 2396: characters not allowed for various reasons.
    unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),

    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
    autoEscape = ['\''].concat(unwise),
    // Characters that are never ever allowed in a hostname.
    // Note that any invalid chars are also handled, but these
    // are the ones that are *expected* to be seen, so we fast-path
    // them.
    nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
    hostEndingChars = ['/', '?', '#'],
    hostnameMaxLen = 255,
    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
    // protocols that can allow "unsafe" and "unwise" chars.
    unsafeProtocol = {
      'javascript': true,
      'javascript:': true
    },
    // protocols that never have a hostname.
    hostlessProtocol = {
      'javascript': true,
      'javascript:': true
    },
    // protocols that always contain a // bit.
    slashedProtocol = {
      'http': true,
      'https': true,
      'ftp': true,
      'gopher': true,
      'file': true,
      'http:': true,
      'https:': true,
      'ftp:': true,
      'gopher:': true,
      'file:': true
    },
    querystring = require('querystring');

function urlParse(url, parseQueryString, slashesDenoteHost) {
  if (url && util.isObject(url) && url instanceof Url) return url;

  var u = new Url;
  u.parse(url, parseQueryString, slashesDenoteHost);
  return u;
}

Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
  if (!util.isString(url)) {
    throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
  }

  // Copy chrome, IE, opera backslash-handling behavior.
  // Back slashes before the query string get converted to forward slashes
  // See: https://code.google.com/p/chromium/issues/detail?id=25916
  var queryIndex = url.indexOf('?'),
      splitter =
          (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
      uSplit = url.split(splitter),
      slashRegex = /\\/g;
  uSplit[0] = uSplit[0].replace(slashRegex, '/');
  url = uSplit.join(splitter);

  var rest = url;

  // trim before proceeding.
  // This is to support parse stuff like "  http://foo.com  \n"
  rest = rest.trim();

  if (!slashesDenoteHost && url.split('#').length === 1) {
    // Try fast path regexp
    var simplePath = simplePathPattern.exec(rest);
    if (simplePath) {
      this.path = rest;
      this.href = rest;
      this.pathname = simplePath[1];
      if (simplePath[2]) {
        this.search = simplePath[2];
        if (parseQueryString) {
          this.query = querystring.parse(this.search.substr(1));
        } else {
          this.query = this.search.substr(1);
        }
      } else if (parseQueryString) {
        this.search = '';
        this.query = {};
      }
      return this;
    }
  }

  var proto = protocolPattern.exec(rest);
  if (proto) {
    proto = proto[0];
    var lowerProto = proto.toLowerCase();
    this.protocol = lowerProto;
    rest = rest.substr(proto.length);
  }

  // figure out if it's got a host
  // user@server is *always* interpreted as a hostname, and url
  // resolution will treat //foo/bar as host=foo,path=bar because that's
  // how the browser resolves relative URLs.
  if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
    var slashes = rest.substr(0, 2) === '//';
    if (slashes && !(proto && hostlessProtocol[proto])) {
      rest = rest.substr(2);
      this.slashes = true;
    }
  }

  if (!hostlessProtocol[proto] &&
      (slashes || (proto && !slashedProtocol[proto]))) {

    // there's a hostname.
    // the first instance of /, ?, ;, or # ends the host.
    //
    // If there is an @ in the hostname, then non-host chars *are* allowed
    // to the left of the last @ sign, unless some host-ending character
    // comes *before* the @-sign.
    // URLs are obnoxious.
    //
    // ex:
    // http://a@b@c/ => user:a@b host:c
    // http://a@b?@c => user:a host:c path:/?@c

    // v0.12 TODO(isaacs): This is not quite how Chrome does things.
    // Review our test case against browsers more comprehensively.

    // find the first instance of any hostEndingChars
    var hostEnd = -1;
    for (var i = 0; i < hostEndingChars.length; i++) {
      var hec = rest.indexOf(hostEndingChars[i]);
      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
        hostEnd = hec;
    }

    // at this point, either we have an explicit point where the
    // auth portion cannot go past, or the last @ char is the decider.
    var auth, atSign;
    if (hostEnd === -1) {
      // atSign can be anywhere.
      atSign = rest.lastIndexOf('@');
    } else {
      // atSign must be in auth portion.
      // http://a@b/c@d => host:b auth:a path:/c@d
      atSign = rest.lastIndexOf('@', hostEnd);
    }

    // Now we have a portion which is definitely the auth.
    // Pull that off.
    if (atSign !== -1) {
      auth = rest.slice(0, atSign);
      rest = rest.slice(atSign + 1);
      this.auth = decodeURIComponent(auth);
    }

    // the host is the remaining to the left of the first non-host char
    hostEnd = -1;
    for (var i = 0; i < nonHostChars.length; i++) {
      var hec = rest.indexOf(nonHostChars[i]);
      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
        hostEnd = hec;
    }
    // if we still have not hit it, then the entire thing is a host.
    if (hostEnd === -1)
      hostEnd = rest.length;

    this.host = rest.slice(0, hostEnd);
    rest = rest.slice(hostEnd);

    // pull out port.
    this.parseHost();

    // we've indicated that there is a hostname,
    // so even if it's empty, it has to be present.
    this.hostname = this.hostname || '';

    // if hostname begins with [ and ends with ]
    // assume that it's an IPv6 address.
    var ipv6Hostname = this.hostname[0] === '[' &&
        this.hostname[this.hostname.length - 1] === ']';

    // validate a little.
    if (!ipv6Hostname) {
      var hostparts = this.hostname.split(/\./);
      for (var i = 0, l = hostparts.length; i < l; i++) {
        var part = hostparts[i];
        if (!part) continue;
        if (!part.match(hostnamePartPattern)) {
          var newpart = '';
          for (var j = 0, k = part.length; j < k; j++) {
            if (part.charCodeAt(j) > 127) {
              // we replace non-ASCII char with a temporary placeholder
              // we need this to make sure size of hostname is not
              // broken by replacing non-ASCII by nothing
              newpart += 'x';
            } else {
              newpart += part[j];
            }
          }
          // we test again with ASCII char only
          if (!newpart.match(hostnamePartPattern)) {
            var validParts = hostparts.slice(0, i);
            var notHost = hostparts.slice(i + 1);
            var bit = part.match(hostnamePartStart);
            if (bit) {
              validParts.push(bit[1]);
              notHost.unshift(bit[2]);
            }
            if (notHost.length) {
              rest = '/' + notHost.join('.') + rest;
            }
            this.hostname = validParts.join('.');
            break;
          }
        }
      }
    }

    if (this.hostname.length > hostnameMaxLen) {
      this.hostname = '';
    } else {
      // hostnames are always lower case.
      this.hostname = this.hostname.toLowerCase();
    }

    if (!ipv6Hostname) {
      // IDNA Support: Returns a punycoded representation of "domain".
      // It only converts parts of the domain name that
      // have non-ASCII characters, i.e. it doesn't matter if
      // you call it with a domain that already is ASCII-only.
      this.hostname = punycode.toASCII(this.hostname);
    }

    var p = this.port ? ':' + this.port : '';
    var h = this.hostname || '';
    this.host = h + p;
    this.href += this.host;

    // strip [ and ] from the hostname
    // the host field still retains them, though
    if (ipv6Hostname) {
      this.hostname = this.hostname.substr(1, this.hostname.length - 2);
      if (rest[0] !== '/') {
        rest = '/' + rest;
      }
    }
  }

  // now rest is set to the post-host stuff.
  // chop off any delim chars.
  if (!unsafeProtocol[lowerProto]) {

    // First, make 100% sure that any "autoEscape" chars get
    // escaped, even if encodeURIComponent doesn't think they
    // need to be.
    for (var i = 0, l = autoEscape.length; i < l; i++) {
      var ae = autoEscape[i];
      if (rest.indexOf(ae) === -1)
        continue;
      var esc = encodeURIComponent(ae);
      if (esc === ae) {
        esc = escape(ae);
      }
      rest = rest.split(ae).join(esc);
    }
  }


  // chop off from the tail first.
  var hash = rest.indexOf('#');
  if (hash !== -1) {
    // got a fragment string.
    this.hash = rest.substr(hash);
    rest = rest.slice(0, hash);
  }
  var qm = rest.indexOf('?');
  if (qm !== -1) {
    this.search = rest.substr(qm);
    this.query = rest.substr(qm + 1);
    if (parseQueryString) {
      this.query = querystring.parse(this.query);
    }
    rest = rest.slice(0, qm);
  } else if (parseQueryString) {
    // no query string, but parseQueryString still requested
    this.search = '';
    this.query = {};
  }
  if (rest) this.pathname = rest;
  if (slashedProtocol[lowerProto] &&
      this.hostname && !this.pathname) {
    this.pathname = '/';
  }

  //to support http.request
  if (this.pathname || this.search) {
    var p = this.pathname || '';
    var s = this.search || '';
    this.path = p + s;
  }

  // finally, reconstruct the href based on what has been validated.
  this.href = this.format();
  return this;
};

// format a parsed object into a url string
function urlFormat(obj) {
  // ensure it's an object, and not a string url.
  // If it's an obj, this is a no-op.
  // this way, you can call url_format() on strings
  // to clean up potentially wonky urls.
  if (util.isString(obj)) obj = urlParse(obj);
  if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
  return obj.format();
}

Url.prototype.format = function() {
  var auth = this.auth || '';
  if (auth) {
    auth = encodeURIComponent(auth);
    auth = auth.replace(/%3A/i, ':');
    auth += '@';
  }

  var protocol = this.protocol || '',
      pathname = this.pathname || '',
      hash = this.hash || '',
      host = false,
      query = '';

  if (this.host) {
    host = auth + this.host;
  } else if (this.hostname) {
    host = auth + (this.hostname.indexOf(':') === -1 ?
        this.hostname :
        '[' + this.hostname + ']');
    if (this.port) {
      host += ':' + this.port;
    }
  }

  if (this.query &&
      util.isObject(this.query) &&
      Object.keys(this.query).length) {
    query = querystring.stringify(this.query);
  }

  var search = this.search || (query && ('?' + query)) || '';

  if (protocol && protocol.substr(-1) !== ':') protocol += ':';

  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
  // unless they had them to begin with.
  if (this.slashes ||
      (!protocol || slashedProtocol[protocol]) && host !== false) {
    host = '//' + (host || '');
    if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
  } else if (!host) {
    host = '';
  }

  if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
  if (search && search.charAt(0) !== '?') search = '?' + search;

  pathname = pathname.replace(/[?#]/g, function(match) {
    return encodeURIComponent(match);
  });
  search = search.replace('#', '%23');

  return protocol + host + pathname + search + hash;
};

function urlResolve(source, relative) {
  return urlParse(source, false, true).resolve(relative);
}

Url.prototype.resolve = function(relative) {
  return this.resolveObject(urlParse(relative, false, true)).format();
};

function urlResolveObject(source, relative) {
  if (!source) return relative;
  return urlParse(source, false, true).resolveObject(relative);
}

Url.prototype.resolveObject = function(relative) {
  if (util.isString(relative)) {
    var rel = new Url();
    rel.parse(relative, false, true);
    relative = rel;
  }

  var result = new Url();
  var tkeys = Object.keys(this);
  for (var tk = 0; tk < tkeys.length; tk++) {
    var tkey = tkeys[tk];
    result[tkey] = this[tkey];
  }

  // hash is always overridden, no matter what.
  // even href="" will remove it.
  result.hash = relative.hash;

  // if the relative url is empty, then there's nothing left to do here.
  if (relative.href === '') {
    result.href = result.format();
    return result;
  }

  // hrefs like //foo/bar always cut to the protocol.
  if (relative.slashes && !relative.protocol) {
    // take everything except the protocol from relative
    var rkeys = Object.keys(relative);
    for (var rk = 0; rk < rkeys.length; rk++) {
      var rkey = rkeys[rk];
      if (rkey !== 'protocol')
        result[rkey] = relative[rkey];
    }

    //urlParse appends trailing / to urls like http://www.example.com
    if (slashedProtocol[result.protocol] &&
        result.hostname && !result.pathname) {
      result.path = result.pathname = '/';
    }

    result.href = result.format();
    return result;
  }

  if (relative.protocol && relative.protocol !== result.protocol) {
    // if it's a known url protocol, then changing
    // the protocol does weird things
    // first, if it's not file:, then we MUST have a host,
    // and if there was a path
    // to begin with, then we MUST have a path.
    // if it is file:, then the host is dropped,
    // because that's known to be hostless.
    // anything else is assumed to be absolute.
    if (!slashedProtocol[relative.protocol]) {
      var keys = Object.keys(relative);
      for (var v = 0; v < keys.length; v++) {
        var k = keys[v];
        result[k] = relative[k];
      }
      result.href = result.format();
      return result;
    }

    result.protocol = relative.protocol;
    if (!relative.host && !hostlessProtocol[relative.protocol]) {
      var relPath = (relative.pathname || '').split('/');
      while (relPath.length && !(relative.host = relPath.shift()));
      if (!relative.host) relative.host = '';
      if (!relative.hostname) relative.hostname = '';
      if (relPath[0] !== '') relPath.unshift('');
      if (relPath.length < 2) relPath.unshift('');
      result.pathname = relPath.join('/');
    } else {
      result.pathname = relative.pathname;
    }
    result.search = relative.search;
    result.query = relative.query;
    result.host = relative.host || '';
    result.auth = relative.auth;
    result.hostname = relative.hostname || relative.host;
    result.port = relative.port;
    // to support http.request
    if (result.pathname || result.search) {
      var p = result.pathname || '';
      var s = result.search || '';
      result.path = p + s;
    }
    result.slashes = result.slashes || relative.slashes;
    result.href = result.format();
    return result;
  }

  var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
      isRelAbs = (
          relative.host ||
          relative.pathname && relative.pathname.charAt(0) === '/'
      ),
      mustEndAbs = (isRelAbs || isSourceAbs ||
                    (result.host && relative.pathname)),
      removeAllDots = mustEndAbs,
      srcPath = result.pathname && result.pathname.split('/') || [],
      relPath = relative.pathname && relative.pathname.split('/') || [],
      psychotic = result.protocol && !slashedProtocol[result.protocol];

  // if the url is a non-slashed url, then relative
  // links like ../.. should be able
  // to crawl up to the hostname, as well.  This is strange.
  // result.protocol has already been set by now.
  // Later on, put the first path part into the host field.
  if (psychotic) {
    result.hostname = '';
    result.port = null;
    if (result.host) {
      if (srcPath[0] === '') srcPath[0] = result.host;
      else srcPath.unshift(result.host);
    }
    result.host = '';
    if (relative.protocol) {
      relative.hostname = null;
      relative.port = null;
      if (relative.host) {
        if (relPath[0] === '') relPath[0] = relative.host;
        else relPath.unshift(relative.host);
      }
      relative.host = null;
    }
    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
  }

  if (isRelAbs) {
    // it's absolute.
    result.host = (relative.host || relative.host === '') ?
                  relative.host : result.host;
    result.hostname = (relative.hostname || relative.hostname === '') ?
                      relative.hostname : result.hostname;
    result.search = relative.search;
    result.query = relative.query;
    srcPath = relPath;
    // fall through to the dot-handling below.
  } else if (relPath.length) {
    // it's relative
    // throw away the existing file, and take the new path instead.
    if (!srcPath) srcPath = [];
    srcPath.pop();
    srcPath = srcPath.concat(relPath);
    result.search = relative.search;
    result.query = relative.query;
  } else if (!util.isNullOrUndefined(relative.search)) {
    // just pull out the search.
    // like href='?foo'.
    // Put this after the other two cases because it simplifies the booleans
    if (psychotic) {
      result.hostname = result.host = srcPath.shift();
      //occationaly the auth can get stuck only in host
      //this especially happens in cases like
      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
      var authInHost = result.host && result.host.indexOf('@') > 0 ?
                       result.host.split('@') : false;
      if (authInHost) {
        result.auth = authInHost.shift();
        result.host = result.hostname = authInHost.shift();
      }
    }
    result.search = relative.search;
    result.query = relative.query;
    //to support http.request
    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
      result.path = (result.pathname ? result.pathname : '') +
                    (result.search ? result.search : '');
    }
    result.href = result.format();
    return result;
  }

  if (!srcPath.length) {
    // no path at all.  easy.
    // we've already handled the other stuff above.
    result.pathname = null;
    //to support http.request
    if (result.search) {
      result.path = '/' + result.search;
    } else {
      result.path = null;
    }
    result.href = result.format();
    return result;
  }

  // if a url ENDs in . or .., then it must get a trailing slash.
  // however, if it ends in anything else non-slashy,
  // then it must NOT get a trailing slash.
  var last = srcPath.slice(-1)[0];
  var hasTrailingSlash = (
      (result.host || relative.host || srcPath.length > 1) &&
      (last === '.' || last === '..') || last === '');

  // strip single dots, resolve double dots to parent dir
  // if the path tries to go above the root, `up` ends up > 0
  var up = 0;
  for (var i = srcPath.length; i >= 0; i--) {
    last = srcPath[i];
    if (last === '.') {
      srcPath.splice(i, 1);
    } else if (last === '..') {
      srcPath.splice(i, 1);
      up++;
    } else if (up) {
      srcPath.splice(i, 1);
      up--;
    }
  }

  // if the path is allowed to go above the root, restore leading ..s
  if (!mustEndAbs && !removeAllDots) {
    for (; up--; up) {
      srcPath.unshift('..');
    }
  }

  if (mustEndAbs && srcPath[0] !== '' &&
      (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
    srcPath.unshift('');
  }

  if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
    srcPath.push('');
  }

  var isAbsolute = srcPath[0] === '' ||
      (srcPath[0] && srcPath[0].charAt(0) === '/');

  // put the host back
  if (psychotic) {
    result.hostname = result.host = isAbsolute ? '' :
                                    srcPath.length ? srcPath.shift() : '';
    //occationaly the auth can get stuck only in host
    //this especially happens in cases like
    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
    var authInHost = result.host && result.host.indexOf('@') > 0 ?
                     result.host.split('@') : false;
    if (authInHost) {
      result.auth = authInHost.shift();
      result.host = result.hostname = authInHost.shift();
    }
  }

  mustEndAbs = mustEndAbs || (result.host && srcPath.length);

  if (mustEndAbs && !isAbsolute) {
    srcPath.unshift('');
  }

  if (!srcPath.length) {
    result.pathname = null;
    result.path = null;
  } else {
    result.pathname = srcPath.join('/');
  }

  //to support request.http
  if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
    result.path = (result.pathname ? result.pathname : '') +
                  (result.search ? result.search : '');
  }
  result.auth = relative.auth || result.auth;
  result.slashes = result.slashes || relative.slashes;
  result.href = result.format();
  return result;
};

Url.prototype.parseHost = function() {
  var host = this.host;
  var port = portPattern.exec(host);
  if (port) {
    port = port[0];
    if (port !== ':') {
      this.port = port.substr(1);
    }
    host = host.substr(0, host.length - port.length);
  }
  if (host) this.hostname = host;
};

},{"./util":754,"punycode":726,"querystring":729}],754:[function(require,module,exports){
'use strict';

module.exports = {
  isString: function(arg) {
    return typeof(arg) === 'string';
  },
  isObject: function(arg) {
    return typeof(arg) === 'object' && arg !== null;
  },
  isNull: function(arg) {
    return arg === null;
  },
  isNullOrUndefined: function(arg) {
    return arg == null;
  }
};

},{}],755:[function(require,module,exports){
(function (global){(function (){

/**
 * Module exports.
 */

module.exports = deprecate;

/**
 * Mark that a method should not be used.
 * Returns a modified function which warns once by default.
 *
 * If `localStorage.noDeprecation = true` is set, then it is a no-op.
 *
 * If `localStorage.throwDeprecation = true` is set, then deprecated functions
 * will throw an Error when invoked.
 *
 * If `localStorage.traceDeprecation = true` is set, then deprecated functions
 * will invoke `console.trace()` instead of `console.error()`.
 *
 * @param {Function} fn - the function to deprecate
 * @param {String} msg - the string to print to the console when `fn` is invoked
 * @returns {Function} a new "deprecated" version of `fn`
 * @api public
 */

function deprecate (fn, msg) {
  if (config('noDeprecation')) {
    return fn;
  }

  var warned = false;
  function deprecated() {
    if (!warned) {
      if (config('throwDeprecation')) {
        throw new Error(msg);
      } else if (config('traceDeprecation')) {
        console.trace(msg);
      } else {
        console.warn(msg);
      }
      warned = true;
    }
    return fn.apply(this, arguments);
  }

  return deprecated;
}

/**
 * Checks `localStorage` for boolean values for the given `name`.
 *
 * @param {String} name
 * @returns {Boolean}
 * @api private
 */

function config (name) {
  // accessing global.localStorage can trigger a DOMException in sandboxed iframes
  try {
    if (!global.localStorage) return false;
  } catch (_) {
    return false;
  }
  var val = global.localStorage[name];
  if (null == val) return false;
  return String(val).toLowerCase() === 'true';
}

}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{}],756:[function(require,module,exports){
module.exports = extend

var hasOwnProperty = Object.prototype.hasOwnProperty;

function extend() {
    var target = {}

    for (var i = 0; i < arguments.length; i++) {
        var source = arguments[i]

        for (var key in source) {
            if (hasOwnProperty.call(source, key)) {
                target[key] = source[key]
            }
        }
    }

    return target
}

},{}]},{},[1])
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","browser/app.js","dist/assert-exists.js","dist/consts.js","dist/convars.js","dist/crosshair.js","dist/demo.js","dist/entities.js","dist/entities/baseentity.js","dist/entities/gamerules.js","dist/entities/itemdefs.js","dist/entities/networkable.js","dist/entities/player.js","dist/entities/projectile.js","dist/entities/team.js","dist/entities/weapon.js","dist/entityhandle.js","dist/eventtypes.js","dist/ext/bitbuffer.js","dist/gameevent.js","dist/gameevents.js","dist/icekey.js","dist/net.js","dist/props.js","dist/protobufs/cstrike15_gcmessages.js","dist/protobufs/cstrike15_usermessages.js","dist/protobufs/engine_gcmessages.js","dist/protobufs/netmessages.js","dist/sharecode.js","dist/stringtables.js","dist/supplements/grenadetrajectory.js","dist/supplements/itempurchase.js","dist/supplements/molotovdetonate.js","dist/usermessages.js","dist/usermessagetypes.js","node_modules/@babel/runtime/helpers/AsyncGenerator.js","node_modules/@babel/runtime/helpers/AwaitValue.js","node_modules/@babel/runtime/helpers/arrayLikeToArray.js","node_modules/@babel/runtime/helpers/arrayWithHoles.js","node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","node_modules/@babel/runtime/helpers/assertThisInitialized.js","node_modules/@babel/runtime/helpers/asyncGeneratorDelegate.js","node_modules/@babel/runtime/helpers/asyncIterator.js","node_modules/@babel/runtime/helpers/asyncToGenerator.js","node_modules/@babel/runtime/helpers/awaitAsyncGenerator.js","node_modules/@babel/runtime/helpers/classCallCheck.js","node_modules/@babel/runtime/helpers/construct.js","node_modules/@babel/runtime/helpers/createClass.js","node_modules/@babel/runtime/helpers/defineProperty.js","node_modules/@babel/runtime/helpers/get.js","node_modules/@babel/runtime/helpers/getPrototypeOf.js","node_modules/@babel/runtime/helpers/inherits.js","node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js","node_modules/@babel/runtime/helpers/iterableToArray.js","node_modules/@babel/runtime/helpers/iterableToArrayLimit.js","node_modules/@babel/runtime/helpers/nonIterableRest.js","node_modules/@babel/runtime/helpers/nonIterableSpread.js","node_modules/@babel/runtime/helpers/possibleConstructorReturn.js","node_modules/@babel/runtime/helpers/setPrototypeOf.js","node_modules/@babel/runtime/helpers/slicedToArray.js","node_modules/@babel/runtime/helpers/superPropBase.js","node_modules/@babel/runtime/helpers/toConsumableArray.js","node_modules/@babel/runtime/helpers/typeof.js","node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","node_modules/@babel/runtime/helpers/wrapAsyncGenerator.js","node_modules/@babel/runtime/regenerator/index.js","node_modules/@protobufjs/aspromise/index.js","node_modules/@protobufjs/base64/index.js","node_modules/@protobufjs/eventemitter/index.js","node_modules/@protobufjs/float/index.js","node_modules/@protobufjs/inquire/index.js","node_modules/@protobufjs/pool/index.js","node_modules/@protobufjs/utf8/index.js","node_modules/assert/assert.js","node_modules/assert/node_modules/inherits/inherits_browser.js","node_modules/assert/node_modules/util/support/isBufferBrowser.js","node_modules/assert/node_modules/util/util.js","node_modules/base64-js/index.js","node_modules/big-integer/BigInteger.js","node_modules/bit-buffer/bit-buffer.js","node_modules/browser-resolve/empty.js","node_modules/browserify/node_modules/buffer/index.js","node_modules/builtin-status-codes/browser.js","node_modules/bytebuffer/dist/bytebuffer.js","node_modules/events/events.js","node_modules/https-browserify/index.js","node_modules/ieee754/index.js","node_modules/immutable/dist/immutable.js","node_modules/inherits/inherits_browser.js","node_modules/iter-tools/__methods/append.js","node_modules/iter-tools/__methods/apply.js","node_modules/iter-tools/__methods/array-reverse.js","node_modules/iter-tools/__methods/async-append.js","node_modules/iter-tools/__methods/async-batch.js","node_modules/iter-tools/__methods/async-bisect.js","node_modules/iter-tools/__methods/async-buffer.js","node_modules/iter-tools/__methods/async-collate.js","node_modules/iter-tools/__methods/async-compress.js","node_modules/iter-tools/__methods/async-concat.js","node_modules/iter-tools/__methods/async-consume.js","node_modules/iter-tools/__methods/async-cycle-times.js","node_modules/iter-tools/__methods/async-cycle.js","node_modules/iter-tools/__methods/async-deep-equal.js","node_modules/iter-tools/__methods/async-distinct.js","node_modules/iter-tools/__methods/async-drop-while.js","node_modules/iter-tools/__methods/async-drop.js","node_modules/iter-tools/__methods/async-enumerate.js","node_modules/iter-tools/__methods/async-equal.js","node_modules/iter-tools/__methods/async-every.js","node_modules/iter-tools/__methods/async-filter.js","node_modules/iter-tools/__methods/async-find-best-or.js","node_modules/iter-tools/__methods/async-find-best.js","node_modules/iter-tools/__methods/async-find-or.js","node_modules/iter-tools/__methods/async-find.js","node_modules/iter-tools/__methods/async-first-or.js","node_modules/iter-tools/__methods/async-first.js","node_modules/iter-tools/__methods/async-flat-map.js","node_modules/iter-tools/__methods/async-flat.js","node_modules/iter-tools/__methods/async-for-each.js","node_modules/iter-tools/__methods/async-fork.js","node_modules/iter-tools/__methods/async-forkerate.js","node_modules/iter-tools/__methods/async-includes-any-seq.js","node_modules/iter-tools/__methods/async-includes-any.js","node_modules/iter-tools/__methods/async-includes-seq.js","node_modules/iter-tools/__methods/async-includes.js","node_modules/iter-tools/__methods/async-interleave-ready.js","node_modules/iter-tools/__methods/async-interleave.js","node_modules/iter-tools/__methods/async-interpose-seq.js","node_modules/iter-tools/__methods/async-interpose.js","node_modules/iter-tools/__methods/async-is-empty.js","node_modules/iter-tools/__methods/async-is-sorted.js","node_modules/iter-tools/__methods/async-join-with-seq.js","node_modules/iter-tools/__methods/async-join-with.js","node_modules/iter-tools/__methods/async-join.js","node_modules/iter-tools/__methods/async-map.js","node_modules/iter-tools/__methods/async-peekerate.js","node_modules/iter-tools/__methods/async-prepend.js","node_modules/iter-tools/__methods/async-reduce.js","node_modules/iter-tools/__methods/async-reverse.js","node_modules/iter-tools/__methods/async-round-robin.js","node_modules/iter-tools/__methods/async-size.js","node_modules/iter-tools/__methods/async-slice.js","node_modules/iter-tools/__methods/async-some.js","node_modules/iter-tools/__methods/async-split-groups.js","node_modules/iter-tools/__methods/async-split-on-any-seq.js","node_modules/iter-tools/__methods/async-split-on-any.js","node_modules/iter-tools/__methods/async-split-on-seq.js","node_modules/iter-tools/__methods/async-split-on.js","node_modules/iter-tools/__methods/async-split-when.js","node_modules/iter-tools/__methods/async-split.js","node_modules/iter-tools/__methods/async-spliterate-grouped.js","node_modules/iter-tools/__methods/async-spliterate.js","node_modules/iter-tools/__methods/async-starts-with-any-seq.js","node_modules/iter-tools/__methods/async-starts-with-any.js","node_modules/iter-tools/__methods/async-starts-with-seq.js","node_modules/iter-tools/__methods/async-starts-with.js","node_modules/iter-tools/__methods/async-str.js","node_modules/iter-tools/__methods/async-take-last-or.js","node_modules/iter-tools/__methods/async-take-last.js","node_modules/iter-tools/__methods/async-take-sorted.js","node_modules/iter-tools/__methods/async-take-while.js","node_modules/iter-tools/__methods/async-take.js","node_modules/iter-tools/__methods/async-tap.js","node_modules/iter-tools/__methods/async-throttle.js","node_modules/iter-tools/__methods/async-to-array.js","node_modules/iter-tools/__methods/async-to-object.js","node_modules/iter-tools/__methods/async-window-ahead.js","node_modules/iter-tools/__methods/async-window-behind.js","node_modules/iter-tools/__methods/async-window.js","node_modules/iter-tools/__methods/async-zip-all.js","node_modules/iter-tools/__methods/async-zip.js","node_modules/iter-tools/__methods/batch.js","node_modules/iter-tools/__methods/bisect.js","node_modules/iter-tools/__methods/call.js","node_modules/iter-tools/__methods/collate.js","node_modules/iter-tools/__methods/compress.js","node_modules/iter-tools/__methods/concat.js","node_modules/iter-tools/__methods/consume.js","node_modules/iter-tools/__methods/cycle-times.js","node_modules/iter-tools/__methods/cycle.js","node_modules/iter-tools/__methods/deep-equal.js","node_modules/iter-tools/__methods/distinct.js","node_modules/iter-tools/__methods/drop-while.js","node_modules/iter-tools/__methods/drop.js","node_modules/iter-tools/__methods/enumerate.js","node_modules/iter-tools/__methods/equal.js","node_modules/iter-tools/__methods/every.js","node_modules/iter-tools/__methods/filter.js","node_modules/iter-tools/__methods/find-best-or.js","node_modules/iter-tools/__methods/find-best.js","node_modules/iter-tools/__methods/find-or.js","node_modules/iter-tools/__methods/find.js","node_modules/iter-tools/__methods/first-or.js","node_modules/iter-tools/__methods/first.js","node_modules/iter-tools/__methods/flat-map.js","node_modules/iter-tools/__methods/flat.js","node_modules/iter-tools/__methods/for-each.js","node_modules/iter-tools/__methods/fork.js","node_modules/iter-tools/__methods/forkerate.js","node_modules/iter-tools/__methods/includes-any-seq.js","node_modules/iter-tools/__methods/includes-any.js","node_modules/iter-tools/__methods/includes-seq.js","node_modules/iter-tools/__methods/includes.js","node_modules/iter-tools/__methods/interleave.js","node_modules/iter-tools/__methods/interpose-seq.js","node_modules/iter-tools/__methods/interpose.js","node_modules/iter-tools/__methods/is-empty.js","node_modules/iter-tools/__methods/is-sorted.js","node_modules/iter-tools/__methods/join-with-seq.js","node_modules/iter-tools/__methods/join-with.js","node_modules/iter-tools/__methods/join.js","node_modules/iter-tools/__methods/map.js","node_modules/iter-tools/__methods/object-entries.js","node_modules/iter-tools/__methods/object-keys.js","node_modules/iter-tools/__methods/object-values.js","node_modules/iter-tools/__methods/peekerate.js","node_modules/iter-tools/__methods/prepend.js","node_modules/iter-tools/__methods/range.js","node_modules/iter-tools/__methods/reduce.js","node_modules/iter-tools/__methods/repeat-times.js","node_modules/iter-tools/__methods/repeat.js","node_modules/iter-tools/__methods/reverse.js","node_modules/iter-tools/__methods/round-robin.js","node_modules/iter-tools/__methods/size.js","node_modules/iter-tools/__methods/slice.js","node_modules/iter-tools/__methods/some.js","node_modules/iter-tools/__methods/split-groups.js","node_modules/iter-tools/__methods/split-on-any-seq.js","node_modules/iter-tools/__methods/split-on-any.js","node_modules/iter-tools/__methods/split-on-seq.js","node_modules/iter-tools/__methods/split-on.js","node_modules/iter-tools/__methods/split-when.js","node_modules/iter-tools/__methods/split.js","node_modules/iter-tools/__methods/spliterate-grouped.js","node_modules/iter-tools/__methods/spliterate.js","node_modules/iter-tools/__methods/starts-with-any-seq.js","node_modules/iter-tools/__methods/starts-with-any.js","node_modules/iter-tools/__methods/starts-with-seq.js","node_modules/iter-tools/__methods/starts-with.js","node_modules/iter-tools/__methods/str.js","node_modules/iter-tools/__methods/take-last-or.js","node_modules/iter-tools/__methods/take-last.js","node_modules/iter-tools/__methods/take-sorted.js","node_modules/iter-tools/__methods/take-while.js","node_modules/iter-tools/__methods/take.js","node_modules/iter-tools/__methods/tap.js","node_modules/iter-tools/__methods/to-array.js","node_modules/iter-tools/__methods/to-object.js","node_modules/iter-tools/__methods/window-ahead.js","node_modules/iter-tools/__methods/window-behind.js","node_modules/iter-tools/__methods/window.js","node_modules/iter-tools/__methods/wrap-entries.js","node_modules/iter-tools/__methods/wrap-keys.js","node_modules/iter-tools/__methods/wrap-values.js","node_modules/iter-tools/__methods/zip-all.js","node_modules/iter-tools/__methods/zip.js","node_modules/iter-tools/impls/$append/append.js","node_modules/iter-tools/impls/$append/async-append.js","node_modules/iter-tools/impls/$batch/async-batch.js","node_modules/iter-tools/impls/$batch/batch.js","node_modules/iter-tools/impls/$bisect/async-bisect.js","node_modules/iter-tools/impls/$bisect/bisect.js","node_modules/iter-tools/impls/$collate/async-collate.js","node_modules/iter-tools/impls/$collate/collate.js","node_modules/iter-tools/impls/$compress/async-compress.js","node_modules/iter-tools/impls/$compress/compress.js","node_modules/iter-tools/impls/$concat/async-concat.js","node_modules/iter-tools/impls/$concat/concat.js","node_modules/iter-tools/impls/$consume/async-consume.js","node_modules/iter-tools/impls/$consume/consume.js","node_modules/iter-tools/impls/$cycle-times/async-cycle-times.js","node_modules/iter-tools/impls/$cycle-times/cycle-times.js","node_modules/iter-tools/impls/$cycle/async-cycle.js","node_modules/iter-tools/impls/$cycle/cycle.js","node_modules/iter-tools/impls/$deep-equal/async-deep-equal.js","node_modules/iter-tools/impls/$deep-equal/deep-equal.js","node_modules/iter-tools/impls/$distinct/async-distinct.js","node_modules/iter-tools/impls/$distinct/distinct.js","node_modules/iter-tools/impls/$drop-while/async-drop-while.js","node_modules/iter-tools/impls/$drop-while/drop-while.js","node_modules/iter-tools/impls/$drop/async-drop.js","node_modules/iter-tools/impls/$drop/drop.js","node_modules/iter-tools/impls/$enumerate/async-enumerate.js","node_modules/iter-tools/impls/$enumerate/enumerate.js","node_modules/iter-tools/impls/$equal/async-equal.js","node_modules/iter-tools/impls/$equal/equal.js","node_modules/iter-tools/impls/$every/async-every.js","node_modules/iter-tools/impls/$every/every.js","node_modules/iter-tools/impls/$filter/async-filter.js","node_modules/iter-tools/impls/$filter/filter.js","node_modules/iter-tools/impls/$find-best-or/async-find-best-or.js","node_modules/iter-tools/impls/$find-best-or/find-best-or.js","node_modules/iter-tools/impls/$find-best/async-find-best.js","node_modules/iter-tools/impls/$find-best/find-best.js","node_modules/iter-tools/impls/$find-or/async-find-or.js","node_modules/iter-tools/impls/$find-or/find-or.js","node_modules/iter-tools/impls/$find/async-find.js","node_modules/iter-tools/impls/$find/find.js","node_modules/iter-tools/impls/$first-or/async-first-or.js","node_modules/iter-tools/impls/$first-or/first-or.js","node_modules/iter-tools/impls/$first/async-first.js","node_modules/iter-tools/impls/$first/first.js","node_modules/iter-tools/impls/$flat-map/async-flat-map.js","node_modules/iter-tools/impls/$flat-map/flat-map.js","node_modules/iter-tools/impls/$flat/async-flat.js","node_modules/iter-tools/impls/$flat/flat.js","node_modules/iter-tools/impls/$flat/internal/validate-args.js","node_modules/iter-tools/impls/$for-each/async-for-each.js","node_modules/iter-tools/impls/$for-each/for-each.js","node_modules/iter-tools/impls/$fork/async-fork.js","node_modules/iter-tools/impls/$fork/fork.js","node_modules/iter-tools/impls/$forkerate/async-forkerate.js","node_modules/iter-tools/impls/$forkerate/forkerate.js","node_modules/iter-tools/impls/$includes-any-seq/async-includes-any-seq.js","node_modules/iter-tools/impls/$includes-any-seq/includes-any-seq.js","node_modules/iter-tools/impls/$includes-any/async-includes-any.js","node_modules/iter-tools/impls/$includes-any/includes-any.js","node_modules/iter-tools/impls/$includes-seq/async-includes-seq.js","node_modules/iter-tools/impls/$includes-seq/includes-seq.js","node_modules/iter-tools/impls/$includes/async-includes.js","node_modules/iter-tools/impls/$includes/includes.js","node_modules/iter-tools/impls/$interleave/async-interleave.js","node_modules/iter-tools/impls/$interleave/interleave.js","node_modules/iter-tools/impls/$interpose-seq/async-interpose-seq.js","node_modules/iter-tools/impls/$interpose-seq/interpose-seq.js","node_modules/iter-tools/impls/$interpose/async-interpose.js","node_modules/iter-tools/impls/$interpose/interpose.js","node_modules/iter-tools/impls/$is-empty/async-is-empty.js","node_modules/iter-tools/impls/$is-empty/is-empty.js","node_modules/iter-tools/impls/$is-sorted/async-is-sorted.js","node_modules/iter-tools/impls/$is-sorted/is-sorted.js","node_modules/iter-tools/impls/$join-with-seq/async-join-with-seq.js","node_modules/iter-tools/impls/$join-with-seq/join-with-seq.js","node_modules/iter-tools/impls/$join-with/async-join-with.js","node_modules/iter-tools/impls/$join-with/join-with.js","node_modules/iter-tools/impls/$join/async-join.js","node_modules/iter-tools/impls/$join/join.js","node_modules/iter-tools/impls/$map/async-map.js","node_modules/iter-tools/impls/$map/map.js","node_modules/iter-tools/impls/$peekerate/async-peekerate.js","node_modules/iter-tools/impls/$peekerate/peekerate.js","node_modules/iter-tools/impls/$prepend/async-prepend.js","node_modules/iter-tools/impls/$prepend/prepend.js","node_modules/iter-tools/impls/$reduce/async-reduce.js","node_modules/iter-tools/impls/$reduce/reduce.js","node_modules/iter-tools/impls/$reverse/async-reverse.js","node_modules/iter-tools/impls/$reverse/reverse.js","node_modules/iter-tools/impls/$round-robin/async-round-robin.js","node_modules/iter-tools/impls/$round-robin/internal/validate-args.js","node_modules/iter-tools/impls/$round-robin/round-robin.js","node_modules/iter-tools/impls/$size/async-size.js","node_modules/iter-tools/impls/$size/size.js","node_modules/iter-tools/impls/$slice/async-slice.js","node_modules/iter-tools/impls/$slice/internal/validate-args.js","node_modules/iter-tools/impls/$slice/slice.js","node_modules/iter-tools/impls/$some/async-some.js","node_modules/iter-tools/impls/$some/some.js","node_modules/iter-tools/impls/$split-groups/async-split-groups.js","node_modules/iter-tools/impls/$split-groups/split-groups.js","node_modules/iter-tools/impls/$split-on-any-seq/async-split-on-any-seq.js","node_modules/iter-tools/impls/$split-on-any-seq/split-on-any-seq.js","node_modules/iter-tools/impls/$split-on-any/async-split-on-any.js","node_modules/iter-tools/impls/$split-on-any/split-on-any.js","node_modules/iter-tools/impls/$split-on-seq/async-split-on-seq.js","node_modules/iter-tools/impls/$split-on-seq/split-on-seq.js","node_modules/iter-tools/impls/$split-on/async-split-on.js","node_modules/iter-tools/impls/$split-on/split-on.js","node_modules/iter-tools/impls/$split-when/async-split-when.js","node_modules/iter-tools/impls/$split-when/split-when.js","node_modules/iter-tools/impls/$split/async-split.js","node_modules/iter-tools/impls/$split/split.js","node_modules/iter-tools/impls/$spliterate-grouped/async-spliterate-grouped.js","node_modules/iter-tools/impls/$spliterate-grouped/spliterate-grouped.js","node_modules/iter-tools/impls/$spliterate/async-spliterate.js","node_modules/iter-tools/impls/$spliterate/spliterate.js","node_modules/iter-tools/impls/$starts-with-any-seq/async-starts-with-any-seq.js","node_modules/iter-tools/impls/$starts-with-any-seq/starts-with-any-seq.js","node_modules/iter-tools/impls/$starts-with-any/async-starts-with-any.js","node_modules/iter-tools/impls/$starts-with-any/starts-with-any.js","node_modules/iter-tools/impls/$starts-with-seq/async-starts-with-seq.js","node_modules/iter-tools/impls/$starts-with-seq/starts-with-seq.js","node_modules/iter-tools/impls/$starts-with/async-starts-with.js","node_modules/iter-tools/impls/$starts-with/starts-with.js","node_modules/iter-tools/impls/$str/async-str.js","node_modules/iter-tools/impls/$str/str.js","node_modules/iter-tools/impls/$take-last-or/async-take-last-or.js","node_modules/iter-tools/impls/$take-last-or/take-last-or.js","node_modules/iter-tools/impls/$take-last/async-take-last.js","node_modules/iter-tools/impls/$take-last/take-last.js","node_modules/iter-tools/impls/$take-sorted/async-take-sorted.js","node_modules/iter-tools/impls/$take-sorted/internal/heap.js","node_modules/iter-tools/impls/$take-sorted/take-sorted.js","node_modules/iter-tools/impls/$take-while/async-take-while.js","node_modules/iter-tools/impls/$take-while/take-while.js","node_modules/iter-tools/impls/$take/async-take.js","node_modules/iter-tools/impls/$take/take.js","node_modules/iter-tools/impls/$tap/async-tap.js","node_modules/iter-tools/impls/$tap/tap.js","node_modules/iter-tools/impls/$to-array/async-to-array.js","node_modules/iter-tools/impls/$to-array/to-array.js","node_modules/iter-tools/impls/$to-object/async-to-object.js","node_modules/iter-tools/impls/$to-object/to-object.js","node_modules/iter-tools/impls/$window-ahead/async-window-ahead.js","node_modules/iter-tools/impls/$window-ahead/window-ahead.js","node_modules/iter-tools/impls/$window-behind/async-window-behind.js","node_modules/iter-tools/impls/$window-behind/window-behind.js","node_modules/iter-tools/impls/$window/async-window.js","node_modules/iter-tools/impls/$window/window.js","node_modules/iter-tools/impls/$wrap/async-wrap.js","node_modules/iter-tools/impls/$wrap/wrap.js","node_modules/iter-tools/impls/$zip-all/async-zip-all.js","node_modules/iter-tools/impls/$zip-all/zip-all.js","node_modules/iter-tools/impls/$zip/async-zip.js","node_modules/iter-tools/impls/$zip/zip.js","node_modules/iter-tools/impls/apply/apply.js","node_modules/iter-tools/impls/array-first-or/array-first-or.js","node_modules/iter-tools/impls/array-first/array-first.js","node_modules/iter-tools/impls/array-from-async/array-from-async.js","node_modules/iter-tools/impls/array-from/array-from.js","node_modules/iter-tools/impls/array-last-or/array-last-or.js","node_modules/iter-tools/impls/array-last/array-last.js","node_modules/iter-tools/impls/array-reverse/array-reverse.js","node_modules/iter-tools/impls/async-buffer/async-buffer.js","node_modules/iter-tools/impls/async-interleave-ready/async-interleave-ready.js","node_modules/iter-tools/impls/async-interleave-ready/internal/race-to.js","node_modules/iter-tools/impls/async-throttle/async-throttle.js","node_modules/iter-tools/impls/call/call.js","node_modules/iter-tools/impls/compose/compose.js","node_modules/iter-tools/impls/exec-pipe/exec-pipe.js","node_modules/iter-tools/impls/first-highest/first-highest.js","node_modules/iter-tools/impls/first-lowest/first-lowest.js","node_modules/iter-tools/impls/get-size/get-size.js","node_modules/iter-tools/impls/is-array/is-array.js","node_modules/iter-tools/impls/is-async-iterable/is-async-iterable.js","node_modules/iter-tools/impls/is-async-loopable/is-async-loopable.js","node_modules/iter-tools/impls/is-async-wrappable/is-async-wrappable.js","node_modules/iter-tools/impls/is-iterable/is-iterable.js","node_modules/iter-tools/impls/is-loopable/is-loopable.js","node_modules/iter-tools/impls/is-nil/is-nil.js","node_modules/iter-tools/impls/is-null/is-null.js","node_modules/iter-tools/impls/is-object/is-object.js","node_modules/iter-tools/impls/is-string/is-string.js","node_modules/iter-tools/impls/is-undefined/is-undefined.js","node_modules/iter-tools/impls/is-wrappable/is-wrappable.js","node_modules/iter-tools/impls/last-highest/last-highest.js","node_modules/iter-tools/impls/last-lowest/last-lowest.js","node_modules/iter-tools/impls/not-array/not-array.js","node_modules/iter-tools/impls/not-async-iterable/not-async-iterable.js","node_modules/iter-tools/impls/not-async-loopable/not-async-loopable.js","node_modules/iter-tools/impls/not-async-wrappable/not-async-wrappable.js","node_modules/iter-tools/impls/not-iterable/not-iterable.js","node_modules/iter-tools/impls/not-loopable/not-loopable.js","node_modules/iter-tools/impls/not-nil/not-nil.js","node_modules/iter-tools/impls/not-null/not-null.js","node_modules/iter-tools/impls/not-object/not-object.js","node_modules/iter-tools/impls/not-string/not-string.js","node_modules/iter-tools/impls/not-undefined/not-undefined.js","node_modules/iter-tools/impls/not-wrappable/not-wrappable.js","node_modules/iter-tools/impls/object-entries/object-entries.js","node_modules/iter-tools/impls/object-from-async/object-from-async.js","node_modules/iter-tools/impls/object-from/object-from.js","node_modules/iter-tools/impls/object-keys/object-keys.js","node_modules/iter-tools/impls/object-values/object-values.js","node_modules/iter-tools/impls/pipe/pipe.js","node_modules/iter-tools/impls/range/range.js","node_modules/iter-tools/impls/repeat-times/repeat-times.js","node_modules/iter-tools/impls/repeat/repeat.js","node_modules/iter-tools/impls/string-from-async/string-from-async.js","node_modules/iter-tools/impls/string-from/string-from.js","node_modules/iter-tools/impls/when/when.js","node_modules/iter-tools/impls/wrap-entries/wrap-entries.js","node_modules/iter-tools/impls/wrap-keys/wrap-keys.js","node_modules/iter-tools/impls/wrap-values/wrap-values.js","node_modules/iter-tools/index.js","node_modules/iter-tools/internal/any-seq.js","node_modules/iter-tools/internal/async-any-seq.js","node_modules/iter-tools/internal/async-bisector.js","node_modules/iter-tools/internal/async-fork.js","node_modules/iter-tools/internal/async-groups-iterator.js","node_modules/iter-tools/internal/async-iterable-iterator.js","node_modules/iter-tools/internal/async-iterable.js","node_modules/iter-tools/internal/async-parallel-each.js","node_modules/iter-tools/internal/async-parts-iterator.js","node_modules/iter-tools/internal/async-peekerator.js","node_modules/iter-tools/internal/async-wrap.js","node_modules/iter-tools/internal/bisector.js","node_modules/iter-tools/internal/circular-buffer.js","node_modules/iter-tools/internal/compare.js","node_modules/iter-tools/internal/curry.js","node_modules/iter-tools/internal/delay.js","node_modules/iter-tools/internal/fork.js","node_modules/iter-tools/internal/groups-iterator.js","node_modules/iter-tools/internal/iterable-iterator.js","node_modules/iter-tools/internal/iterable.js","node_modules/iter-tools/internal/number.js","node_modules/iter-tools/internal/parallel-each.js","node_modules/iter-tools/internal/parts-iterator.js","node_modules/iter-tools/internal/peekerator.js","node_modules/iter-tools/internal/symbols.js","node_modules/iter-tools/internal/wrap.js","node_modules/iter-tools/methods/append.js","node_modules/iter-tools/methods/apply.js","node_modules/iter-tools/methods/array-first-or.js","node_modules/iter-tools/methods/array-first.js","node_modules/iter-tools/methods/array-from-async.js","node_modules/iter-tools/methods/array-from.js","node_modules/iter-tools/methods/array-last-or.js","node_modules/iter-tools/methods/array-last.js","node_modules/iter-tools/methods/array-reverse.js","node_modules/iter-tools/methods/async-append.js","node_modules/iter-tools/methods/async-batch.js","node_modules/iter-tools/methods/async-bisect.js","node_modules/iter-tools/methods/async-buffer.js","node_modules/iter-tools/methods/async-collate.js","node_modules/iter-tools/methods/async-compress.js","node_modules/iter-tools/methods/async-concat.js","node_modules/iter-tools/methods/async-consume.js","node_modules/iter-tools/methods/async-cycle-times.js","node_modules/iter-tools/methods/async-cycle.js","node_modules/iter-tools/methods/async-deep-equal.js","node_modules/iter-tools/methods/async-distinct.js","node_modules/iter-tools/methods/async-drop-while.js","node_modules/iter-tools/methods/async-drop.js","node_modules/iter-tools/methods/async-enumerate.js","node_modules/iter-tools/methods/async-equal.js","node_modules/iter-tools/methods/async-every.js","node_modules/iter-tools/methods/async-filter.js","node_modules/iter-tools/methods/async-find-best-or.js","node_modules/iter-tools/methods/async-find-best.js","node_modules/iter-tools/methods/async-find-or.js","node_modules/iter-tools/methods/async-find.js","node_modules/iter-tools/methods/async-first-or.js","node_modules/iter-tools/methods/async-first.js","node_modules/iter-tools/methods/async-flat-map.js","node_modules/iter-tools/methods/async-flat.js","node_modules/iter-tools/methods/async-for-each.js","node_modules/iter-tools/methods/async-fork.js","node_modules/iter-tools/methods/async-forkerate.js","node_modules/iter-tools/methods/async-includes-any-seq.js","node_modules/iter-tools/methods/async-includes-any.js","node_modules/iter-tools/methods/async-includes-seq.js","node_modules/iter-tools/methods/async-includes.js","node_modules/iter-tools/methods/async-interleave-ready.js","node_modules/iter-tools/methods/async-interleave.js","node_modules/iter-tools/methods/async-interpose-seq.js","node_modules/iter-tools/methods/async-interpose.js","node_modules/iter-tools/methods/async-is-empty.js","node_modules/iter-tools/methods/async-is-sorted.js","node_modules/iter-tools/methods/async-join-with-seq.js","node_modules/iter-tools/methods/async-join-with.js","node_modules/iter-tools/methods/async-join.js","node_modules/iter-tools/methods/async-map.js","node_modules/iter-tools/methods/async-peekerate.js","node_modules/iter-tools/methods/async-prepend.js","node_modules/iter-tools/methods/async-reduce.js","node_modules/iter-tools/methods/async-reverse.js","node_modules/iter-tools/methods/async-round-robin.js","node_modules/iter-tools/methods/async-size.js","node_modules/iter-tools/methods/async-slice.js","node_modules/iter-tools/methods/async-some.js","node_modules/iter-tools/methods/async-split-groups.js","node_modules/iter-tools/methods/async-split-on-any-seq.js","node_modules/iter-tools/methods/async-split-on-any.js","node_modules/iter-tools/methods/async-split-on-seq.js","node_modules/iter-tools/methods/async-split-on.js","node_modules/iter-tools/methods/async-split-when.js","node_modules/iter-tools/methods/async-split.js","node_modules/iter-tools/methods/async-spliterate-grouped.js","node_modules/iter-tools/methods/async-spliterate.js","node_modules/iter-tools/methods/async-starts-with-any-seq.js","node_modules/iter-tools/methods/async-starts-with-any.js","node_modules/iter-tools/methods/async-starts-with-seq.js","node_modules/iter-tools/methods/async-starts-with.js","node_modules/iter-tools/methods/async-str.js","node_modules/iter-tools/methods/async-take-last-or.js","node_modules/iter-tools/methods/async-take-last.js","node_modules/iter-tools/methods/async-take-sorted.js","node_modules/iter-tools/methods/async-take-while.js","node_modules/iter-tools/methods/async-take.js","node_modules/iter-tools/methods/async-tap.js","node_modules/iter-tools/methods/async-throttle.js","node_modules/iter-tools/methods/async-to-array.js","node_modules/iter-tools/methods/async-to-object.js","node_modules/iter-tools/methods/async-window-ahead.js","node_modules/iter-tools/methods/async-window-behind.js","node_modules/iter-tools/methods/async-window.js","node_modules/iter-tools/methods/async-wrap.js","node_modules/iter-tools/methods/async-zip-all.js","node_modules/iter-tools/methods/async-zip.js","node_modules/iter-tools/methods/batch.js","node_modules/iter-tools/methods/bisect.js","node_modules/iter-tools/methods/call.js","node_modules/iter-tools/methods/collate.js","node_modules/iter-tools/methods/compose.js","node_modules/iter-tools/methods/compress.js","node_modules/iter-tools/methods/concat.js","node_modules/iter-tools/methods/consume.js","node_modules/iter-tools/methods/cycle-times.js","node_modules/iter-tools/methods/cycle.js","node_modules/iter-tools/methods/deep-equal.js","node_modules/iter-tools/methods/distinct.js","node_modules/iter-tools/methods/drop-while.js","node_modules/iter-tools/methods/drop.js","node_modules/iter-tools/methods/enumerate.js","node_modules/iter-tools/methods/equal.js","node_modules/iter-tools/methods/every.js","node_modules/iter-tools/methods/exec-pipe.js","node_modules/iter-tools/methods/filter.js","node_modules/iter-tools/methods/find-best-or.js","node_modules/iter-tools/methods/find-best.js","node_modules/iter-tools/methods/find-or.js","node_modules/iter-tools/methods/find.js","node_modules/iter-tools/methods/first-highest.js","node_modules/iter-tools/methods/first-lowest.js","node_modules/iter-tools/methods/first-or.js","node_modules/iter-tools/methods/first.js","node_modules/iter-tools/methods/flat-map.js","node_modules/iter-tools/methods/flat.js","node_modules/iter-tools/methods/for-each.js","node_modules/iter-tools/methods/fork.js","node_modules/iter-tools/methods/forkerate.js","node_modules/iter-tools/methods/get-size.js","node_modules/iter-tools/methods/includes-any-seq.js","node_modules/iter-tools/methods/includes-any.js","node_modules/iter-tools/methods/includes-seq.js","node_modules/iter-tools/methods/includes.js","node_modules/iter-tools/methods/interleave.js","node_modules/iter-tools/methods/interpose-seq.js","node_modules/iter-tools/methods/interpose.js","node_modules/iter-tools/methods/is-array.js","node_modules/iter-tools/methods/is-async-iterable.js","node_modules/iter-tools/methods/is-async-loopable.js","node_modules/iter-tools/methods/is-async-wrappable.js","node_modules/iter-tools/methods/is-empty.js","node_modules/iter-tools/methods/is-iterable.js","node_modules/iter-tools/methods/is-loopable.js","node_modules/iter-tools/methods/is-nil.js","node_modules/iter-tools/methods/is-null.js","node_modules/iter-tools/methods/is-object.js","node_modules/iter-tools/methods/is-sorted.js","node_modules/iter-tools/methods/is-string.js","node_modules/iter-tools/methods/is-undefined.js","node_modules/iter-tools/methods/is-wrappable.js","node_modules/iter-tools/methods/join-with-seq.js","node_modules/iter-tools/methods/join-with.js","node_modules/iter-tools/methods/join.js","node_modules/iter-tools/methods/last-highest.js","node_modules/iter-tools/methods/last-lowest.js","node_modules/iter-tools/methods/map.js","node_modules/iter-tools/methods/not-array.js","node_modules/iter-tools/methods/not-async-iterable.js","node_modules/iter-tools/methods/not-async-loopable.js","node_modules/iter-tools/methods/not-async-wrappable.js","node_modules/iter-tools/methods/not-iterable.js","node_modules/iter-tools/methods/not-loopable.js","node_modules/iter-tools/methods/not-nil.js","node_modules/iter-tools/methods/not-null.js","node_modules/iter-tools/methods/not-object.js","node_modules/iter-tools/methods/not-string.js","node_modules/iter-tools/methods/not-undefined.js","node_modules/iter-tools/methods/not-wrappable.js","node_modules/iter-tools/methods/object-entries.js","node_modules/iter-tools/methods/object-from-async.js","node_modules/iter-tools/methods/object-from.js","node_modules/iter-tools/methods/object-keys.js","node_modules/iter-tools/methods/object-values.js","node_modules/iter-tools/methods/peekerate.js","node_modules/iter-tools/methods/pipe.js","node_modules/iter-tools/methods/prepend.js","node_modules/iter-tools/methods/range.js","node_modules/iter-tools/methods/reduce.js","node_modules/iter-tools/methods/repeat-times.js","node_modules/iter-tools/methods/repeat.js","node_modules/iter-tools/methods/reverse.js","node_modules/iter-tools/methods/round-robin.js","node_modules/iter-tools/methods/size.js","node_modules/iter-tools/methods/slice.js","node_modules/iter-tools/methods/some.js","node_modules/iter-tools/methods/split-groups.js","node_modules/iter-tools/methods/split-on-any-seq.js","node_modules/iter-tools/methods/split-on-any.js","node_modules/iter-tools/methods/split-on-seq.js","node_modules/iter-tools/methods/split-on.js","node_modules/iter-tools/methods/split-when.js","node_modules/iter-tools/methods/split.js","node_modules/iter-tools/methods/spliterate-grouped.js","node_modules/iter-tools/methods/spliterate.js","node_modules/iter-tools/methods/starts-with-any-seq.js","node_modules/iter-tools/methods/starts-with-any.js","node_modules/iter-tools/methods/starts-with-seq.js","node_modules/iter-tools/methods/starts-with.js","node_modules/iter-tools/methods/str.js","node_modules/iter-tools/methods/string-from-async.js","node_modules/iter-tools/methods/string-from.js","node_modules/iter-tools/methods/take-last-or.js","node_modules/iter-tools/methods/take-last.js","node_modules/iter-tools/methods/take-sorted.js","node_modules/iter-tools/methods/take-while.js","node_modules/iter-tools/methods/take.js","node_modules/iter-tools/methods/tap.js","node_modules/iter-tools/methods/to-array.js","node_modules/iter-tools/methods/to-object.js","node_modules/iter-tools/methods/when.js","node_modules/iter-tools/methods/window-ahead.js","node_modules/iter-tools/methods/window-behind.js","node_modules/iter-tools/methods/window.js","node_modules/iter-tools/methods/wrap-entries.js","node_modules/iter-tools/methods/wrap-keys.js","node_modules/iter-tools/methods/wrap-values.js","node_modules/iter-tools/methods/wrap.js","node_modules/iter-tools/methods/zip-all.js","node_modules/iter-tools/methods/zip.js","node_modules/long/dist/long.js","node_modules/object-assign/index.js","node_modules/process/browser.js","node_modules/protobufjs/minimal.js","node_modules/protobufjs/src/index-minimal.js","node_modules/protobufjs/src/reader.js","node_modules/protobufjs/src/reader_buffer.js","node_modules/protobufjs/src/roots.js","node_modules/protobufjs/src/rpc.js","node_modules/protobufjs/src/rpc/service.js","node_modules/protobufjs/src/util/longbits.js","node_modules/protobufjs/src/util/minimal.js","node_modules/protobufjs/src/writer.js","node_modules/protobufjs/src/writer_buffer.js","node_modules/punycode/punycode.js","node_modules/querystring-es3/decode.js","node_modules/querystring-es3/encode.js","node_modules/querystring-es3/index.js","node_modules/regenerator-runtime/runtime.js","node_modules/safe-buffer/index.js","node_modules/stream-http/index.js","node_modules/stream-http/lib/capability.js","node_modules/stream-http/lib/request.js","node_modules/stream-http/lib/response.js","node_modules/stream-http/node_modules/readable-stream/errors-browser.js","node_modules/stream-http/node_modules/readable-stream/lib/_stream_duplex.js","node_modules/stream-http/node_modules/readable-stream/lib/_stream_passthrough.js","node_modules/stream-http/node_modules/readable-stream/lib/_stream_readable.js","node_modules/stream-http/node_modules/readable-stream/lib/_stream_transform.js","node_modules/stream-http/node_modules/readable-stream/lib/_stream_writable.js","node_modules/stream-http/node_modules/readable-stream/lib/internal/streams/async_iterator.js","node_modules/stream-http/node_modules/readable-stream/lib/internal/streams/buffer_list.js","node_modules/stream-http/node_modules/readable-stream/lib/internal/streams/destroy.js","node_modules/stream-http/node_modules/readable-stream/lib/internal/streams/end-of-stream.js","node_modules/stream-http/node_modules/readable-stream/lib/internal/streams/from-browser.js","node_modules/stream-http/node_modules/readable-stream/lib/internal/streams/pipeline.js","node_modules/stream-http/node_modules/readable-stream/lib/internal/streams/state.js","node_modules/stream-http/node_modules/readable-stream/lib/internal/streams/stream-browser.js","node_modules/stream-http/node_modules/readable-stream/readable-browser.js","node_modules/string_decoder/lib/string_decoder.js","node_modules/timers-browserify/main.js","node_modules/url/url.js","node_modules/url/util.js","node_modules/util-deprecate/browser.js","node_modules/xtend/immutable.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AChuBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzqJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1YA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACjNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACzMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5NA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClxVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACv0IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACv8GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC3NA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACr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jGA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/UA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACzGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC1fA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACv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kBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC76CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACrUA;;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACjvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClqHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3gBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACl2LA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7OA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1JA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7LA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1JA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrWA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9MA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACl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pKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9KA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3LA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;;ACJA;AACA;;ACDA;AACA;;ACDA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChBA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;;ACAA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;;ACAA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/DA;AACA;;ACDA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACl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j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jPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7YA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3JA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1CA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzrCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxLA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3ZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACxMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACraA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACrFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACrhBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACr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lvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACjEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACp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hWA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC/HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC1IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnmCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACxMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACxrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AC9MA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACjNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACxGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvGA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACv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tBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","window.Buffer = require(\"buffer\").Buffer;\nwindow.demofile = require(\"../dist/demo\");\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction assertExists(value, message) {\n    if (value == null)\n        throw new Error(message || \"expected non-null value\");\n    return value;\n}\nexports.default = assertExists;\n//# sourceMappingURL=assert-exists.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.SND_STOP = exports.INVALID_NETWORKED_EHANDLE_VALUE = exports.MAX_USERDATA_BITS = exports.SUBSTRING_BITS = exports.MAX_CUSTOM_FILES = exports.SIGNED_GUID_LEN = exports.MAX_PLAYER_NAME_LENGTH = exports.MAX_SPLITSCREEN_CLIENTS = exports.MAX_OSPATH = exports.NUM_NETWORKED_EHANDLE_BITS = exports.NUM_NETWORKED_EHANDLE_SERIAL_NUMBER_BITS = exports.NETWORKED_EHANDLE_ENT_ENTRY_MASK = exports.MAX_EDICTS = exports.MAX_EDICT_BITS = void 0;\nexports.MAX_EDICT_BITS = 11;\nexports.MAX_EDICTS = 1 << exports.MAX_EDICT_BITS;\nexports.NETWORKED_EHANDLE_ENT_ENTRY_MASK = exports.MAX_EDICTS - 1;\nexports.NUM_NETWORKED_EHANDLE_SERIAL_NUMBER_BITS = 10;\nexports.NUM_NETWORKED_EHANDLE_BITS = exports.MAX_EDICT_BITS + exports.NUM_NETWORKED_EHANDLE_SERIAL_NUMBER_BITS;\nexports.MAX_OSPATH = 260;\nexports.MAX_SPLITSCREEN_CLIENTS = 260;\nexports.MAX_PLAYER_NAME_LENGTH = 128;\nexports.SIGNED_GUID_LEN = 32;\nexports.MAX_CUSTOM_FILES = 4;\nexports.SUBSTRING_BITS = 5;\nexports.MAX_USERDATA_BITS = 14;\nexports.INVALID_NETWORKED_EHANDLE_VALUE = (1 << exports.NUM_NETWORKED_EHANDLE_BITS) - 1;\nexports.SND_STOP = 1 << 2;\n//# sourceMappingURL=consts.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ConVars = void 0;\nconst events_1 = require(\"events\");\n/**\n * Manages console variables.\n */\nclass ConVars extends events_1.EventEmitter {\n    constructor() {\n        super(...arguments);\n        this.vars = new Map();\n    }\n    listen(demo) {\n        demo.on(\"net_SetConVar\", (msg) => {\n            const convars = msg.convars;\n            if (!convars)\n                return;\n            for (const cvar of convars.cvars) {\n                const oldValue = this.vars.get(cvar.name);\n                this.vars.set(cvar.name, cvar.value);\n                const args = {\n                    name: cvar.name,\n                    value: cvar.value,\n                    oldValue\n                };\n                this.emit(cvar.name, args);\n                this.emit(\"change\", args);\n            }\n        });\n    }\n}\nexports.ConVars = ConVars;\n//# sourceMappingURL=convars.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.decodeCrosshairCode = exports.CrosshairStyle = void 0;\nconst sharecode_1 = require(\"./sharecode\");\nvar CrosshairStyle;\n(function (CrosshairStyle) {\n    CrosshairStyle[CrosshairStyle[\"Default\"] = 0] = \"Default\";\n    CrosshairStyle[CrosshairStyle[\"DefaultStatic\"] = 1] = \"DefaultStatic\";\n    CrosshairStyle[CrosshairStyle[\"Classic\"] = 2] = \"Classic\";\n    CrosshairStyle[CrosshairStyle[\"ClassicDynamic\"] = 3] = \"ClassicDynamic\";\n    CrosshairStyle[CrosshairStyle[\"ClassicStatic\"] = 4] = \"ClassicStatic\";\n})(CrosshairStyle = exports.CrosshairStyle || (exports.CrosshairStyle = {}));\nfunction decodeCrosshairCode(shareCode) {\n    function signed(byte) {\n        return byte > 127 ? -(~byte & 0xff) - 1 : byte;\n    }\n    const bytes = (0, sharecode_1.decodeShareCode)(shareCode);\n    if (bytes[1] !== bytes.slice(2).reduce((x, y) => x + y) % 256) {\n        throw new Error(\"invalid crosshair code\");\n    }\n    return {\n        outline: bytes[4] / 2,\n        red: bytes[5],\n        green: bytes[6],\n        blue: bytes[7],\n        alpha: bytes[8],\n        splitDistance: bytes[9],\n        innerSplitAlpha: (bytes[11] >> 4) / 10,\n        hasOutline: !!(bytes[11] & 8),\n        outerSplitAlpha: (bytes[12] & 0xf) / 10,\n        splitSizeRatio: (bytes[12] >> 4) / 10,\n        thickness: bytes[13] / 10,\n        length: bytes[15] / 10,\n        gap: signed(bytes[3]) / 10,\n        hasCenterDot: !!((bytes[14] >> 4) & 1),\n        hasAlpha: !!((bytes[14] >> 4) & 4),\n        isTStyle: !!((bytes[14] >> 4) & 8),\n        style: CrosshairStyle[(bytes[14] & 0xf) >> 1]\n    };\n}\nexports.decodeCrosshairCode = decodeCrosshairCode;\n//# sourceMappingURL=crosshair.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.DemoFile = exports.parseHeader = void 0;\nconst events_1 = require(\"events\");\nconst timers = require(\"timers\");\nconst url_1 = require(\"url\");\nconst https = require(\"https\");\nconst ByteBuffer = require(\"bytebuffer\");\nconst bitbuffer_1 = require(\"./ext/bitbuffer\");\nconst assert = require(\"assert\");\nconst consts_1 = require(\"./consts\");\nconst convars_1 = require(\"./convars\");\nconst entities_1 = require(\"./entities\");\nconst gameevents_1 = require(\"./gameevents\");\nconst icekey_1 = require(\"./icekey\");\nconst net = require(\"./net\");\nconst stringtables_1 = require(\"./stringtables\");\nconst usermessages_1 = require(\"./usermessages\");\nconst assert_exists_1 = require(\"./assert-exists\");\nconst grenadetrajectory_1 = require(\"./supplements/grenadetrajectory\");\nconst molotovdetonate_1 = require(\"./supplements/molotovdetonate\");\nconst itempurchase_1 = require(\"./supplements/itempurchase\");\nfunction httpGet(url) {\n    return new Promise((resolve, reject) => {\n        https\n            .request(url, res => {\n            const chunks = [];\n            res.on(\"data\", chunk => {\n                chunks.push(chunk);\n            });\n            res.on(\"end\", () => {\n                if (res.statusCode == 200) {\n                    resolve(Buffer.concat(chunks));\n                }\n                else {\n                    reject(`request '${url}' failed: ${res.statusCode} (${res.statusMessage})`);\n                }\n            });\n        })\n            .end();\n    });\n}\nfunction parseHeaderBytebuf(bytebuf) {\n    return {\n        magic: bytebuf.readString(8, ByteBuffer.METRICS_BYTES).split(\"\\0\", 2)[0],\n        protocol: bytebuf.readInt32(),\n        networkProtocol: bytebuf.readInt32(),\n        serverName: bytebuf\n            .readString(consts_1.MAX_OSPATH, ByteBuffer.METRICS_BYTES)\n            .split(\"\\0\", 2)[0],\n        clientName: bytebuf\n            .readString(consts_1.MAX_OSPATH, ByteBuffer.METRICS_BYTES)\n            .split(\"\\0\", 2)[0],\n        mapName: bytebuf\n            .readString(consts_1.MAX_OSPATH, ByteBuffer.METRICS_BYTES)\n            .split(\"\\0\", 2)[0],\n        gameDirectory: bytebuf\n            .readString(consts_1.MAX_OSPATH, ByteBuffer.METRICS_BYTES)\n            .split(\"\\0\", 2)[0],\n        playbackTime: bytebuf.readFloat(),\n        playbackTicks: bytebuf.readInt32(),\n        playbackFrames: bytebuf.readInt32(),\n        signonLength: bytebuf.readInt32()\n    };\n}\n/**\n * Parses a demo file header from the buffer.\n * @param {ArrayBuffer} buffer - Buffer of the demo header\n * @returns {IDemoHeader} Header object\n */\nfunction parseHeader(buffer) {\n    const bytebuf = ByteBuffer.wrap(buffer, true);\n    return parseHeaderBytebuf(bytebuf);\n}\nexports.parseHeader = parseHeader;\n/**\n * Represents a demo file for parsing.\n */\nclass DemoFile extends events_1.EventEmitter {\n    /**\n     * Starts parsing buffer as a demo file.\n     *\n     * @fires DemoFile#tickstart\n     * @fires DemoFile#tickend\n     * @fires DemoFile#end\n     *\n     * @param {ArrayBuffer} buffer - Buffer pointing to start of demo header\n     */\n    constructor() {\n        super();\n        /**\n         * When parsing, set to current tick.\n         */\n        this.currentTick = -1;\n        /**\n         * Number of seconds per tick\n         */\n        this.tickInterval = NaN;\n        /**\n         * When parsing, set to the splitscreen slot for the current command.\n         * @deprecated Splitscreen slot is unused for PC games.\n         */\n        this.playerSlot = 0;\n        /**\n         * Set to the client slot of the recording player.\n         * Always null for GOTV demos.\n         */\n        this.recordingClientSlot = null;\n        this._chunks = [];\n        this._lastThreadYieldTime = 0;\n        this._immediateTimerToken = null;\n        this._timeoutTimerToken = null;\n        this._encryptionKey = null;\n        this._hasEnded = false;\n        this._isBroadcastFragment = false;\n        this._supplementEvents = [\n            grenadetrajectory_1.default,\n            molotovdetonate_1.default,\n            itempurchase_1.default\n        ];\n        this._supplementCleanupFns = new Map();\n        this.entities = new entities_1.Entities();\n        this.gameEvents = new gameevents_1.GameEvents();\n        this.stringTables = new stringtables_1.StringTables();\n        this.userMessages = new usermessages_1.UserMessages();\n        this.conVars = new convars_1.ConVars();\n        this.gameEvents.listen(this);\n        // It is important that entities listens after game events, as they both listen on\n        // tickend.\n        this.entities.listen(this);\n        this.stringTables.listen(this);\n        this.userMessages.listen(this);\n        this.conVars.listen(this);\n        // #65: Some demos are missing playbackTicks from the header\n        // Pull the tick interval from ServerInfo\n        this.on(\"svc_ServerInfo\", msg => {\n            this.tickInterval = msg.tickInterval;\n        });\n        this.on(\"svc_EncryptedData\", msg => {\n            if (!this._handleEncryptedData(msg)) {\n                // Some demos appear to have the encryption key recorded\n                // incorrectly in the .dem.info file. Don't throw an error\n                // if we can't decode it correctly.\n                // The game client silently skips bad encrypted messages.\n                // See https://github.com/saul/demofile/issues/322#issuecomment-1085776379\n                this.emit(\"warning\", { message: \"Unable to read encrypted message\" });\n            }\n        });\n        this.on(\"newListener\", (event) => {\n            // If we already have listeners for this event, nothing to do\n            if (this.listenerCount(event) > 0)\n                return;\n            const supplement = this._findSupplement(event);\n            if (supplement == null)\n                return;\n            const cleanupFn = supplement.setup(this);\n            this._supplementCleanupFns.set(supplement, cleanupFn);\n        });\n        this.on(\"removeListener\", (event) => {\n            // If there are still listeners for this event, early out\n            if (this.listenerCount(event) > 0)\n                return;\n            const supplement = this._findSupplement(event);\n            if (supplement == null)\n                return;\n            // Don't cleanup if there are listeners on other emits that this supplement emits\n            const existingListenerCount = supplement.emits.reduce((prev, name) => prev + this.listenerCount(name), 0);\n            if (existingListenerCount > 0)\n                return;\n            const cleanupFn = (0, assert_exists_1.default)(this._supplementCleanupFns.get(supplement));\n            cleanupFn();\n            this._supplementCleanupFns.delete(supplement);\n        });\n    }\n    /**\n     * @returns Number of ticks per second\n     */\n    get tickRate() {\n        return 1.0 / this.tickInterval;\n    }\n    /**\n     * @returns Number of seconds elapsed\n     */\n    get currentTime() {\n        return this.currentTick * this.tickInterval;\n    }\n    /**\n     * Shortcut for `this.entities.players`\n     * @returns All connected player entities\n     */\n    get players() {\n        return this.entities.players;\n    }\n    /**\n     * Shortcut for `this.entities.teams`\n     * @returns All team entities\n     */\n    get teams() {\n        return this.entities.teams;\n    }\n    /**\n     * Shortcut for `this.entities.gameRules`\n     * @returns GameRules entity\n     */\n    get gameRules() {\n        return this.entities.gameRules;\n    }\n    _findSupplement(eventName) {\n        for (const supplement of this._supplementEvents) {\n            if (supplement.emits.indexOf(eventName) >= 0)\n                return supplement;\n        }\n        return null;\n    }\n    /**\n     * Start streaming a GOTV broadcast over HTTP.\n     * Will keep streaming until the broadcast finishes.\n     *\n     * @param url URL to the GOTV broadcast.\n     * @returns Promise that resolves then the broadcast finishes.\n     */\n    async parseBroadcast(url) {\n        if (!url.endsWith(\"/\"))\n            url += \"/\";\n        // Some packets are formatted slightly differently in\n        // broadcast fragments compared to a normal demo file.\n        this._isBroadcastFragment = true;\n        const syncUrl = new url_1.URL(\"sync\", url).toString();\n        const syncResponse = await httpGet(syncUrl);\n        const syncDto = JSON.parse(syncResponse.toString());\n        if (syncDto.protocol !== 4) {\n            throw new Error(`expected protocol version 4, got: ${syncDto.protocol}`);\n        }\n        if (syncDto.token_redirect != null) {\n            url = new url_1.URL(syncDto.token_redirect, url).toString();\n            if (!url.endsWith(\"/\"))\n                url += \"/\";\n        }\n        this.header = {\n            magic: \"HL2DEMO\",\n            protocol: syncDto.protocol,\n            networkProtocol: 0,\n            serverName: `GOTV Broadcast: ${url}`,\n            clientName: \"GOTV Demo\",\n            mapName: syncDto.map,\n            gameDirectory: \"csgo\",\n            playbackTime: 0,\n            playbackTicks: 0,\n            playbackFrames: 0,\n            signonLength: 0\n        };\n        this.tickInterval = 1 / syncDto.tps;\n        let cancelled = false;\n        this.emit(\"start\", {\n            cancel() {\n                cancelled = true;\n            }\n        });\n        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n        if (cancelled) {\n            return;\n        }\n        const startUrl = new url_1.URL(`${syncDto.signup_fragment | 0}/start`, url).toString();\n        const startResponse = await httpGet(startUrl);\n        // Read the signon fragment\n        this._bytebuf = ByteBuffer.wrap(startResponse, true);\n        while (this._bytebuf.remaining() > 0) {\n            this._readCommand();\n        }\n        // Keep reading fragments until we run out\n        let fragment = syncDto.fragment | 0;\n        let fragmentType = \"full\";\n        while (!this._hasEnded) {\n            const fragmentUrl = new url_1.URL(`${fragment}/${fragmentType}`, url).toString();\n            let fragmentResponse;\n            try {\n                fragmentResponse = await httpGet(fragmentUrl);\n            }\n            catch {\n                // HTTP 404 errors are expected - each fragment only lasts for a few seconds.\n                // Wait for 1-2 secs before retrying to avoid spamming the relay.\n                await new Promise(resolve => setTimeout(resolve, 1000 + Math.random() * 1000));\n                continue;\n            }\n            // We need to request {fragment}/full + {fragment}/delta\n            if (fragmentType == \"full\") {\n                fragmentType = \"delta\";\n            }\n            else {\n                fragment += 1;\n            }\n            this._bytebuf = ByteBuffer.wrap(fragmentResponse, true);\n            while (this._bytebuf.remaining() > 0) {\n                this._readCommand();\n            }\n        }\n    }\n    parseStream(stream) {\n        this._hasEnded = false;\n        const onReceiveChunk = (chunk) => {\n            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n            if (this._bytebuf == null) {\n                this._bytebuf = ByteBuffer.wrap(chunk, true);\n            }\n            else {\n                this._chunks.push(chunk);\n            }\n        };\n        const readPacketChunk = () => {\n            try {\n                // Keep reading until we can't read any more\n                while (this._bytebuf.remaining() > 0 || this._chunks.length > 0) {\n                    this._bytebuf.mark();\n                    this._readCommand();\n                }\n            }\n            catch (e) {\n                if (e instanceof RangeError) {\n                    // Reset the byte buffer to the start of the last command\n                    this._bytebuf.offset = Math.max(0, this._bytebuf.markedOffset);\n                }\n                else {\n                    stream.off(\"data\", onReceiveChunk);\n                    const error = e instanceof Error\n                        ? e\n                        : new Error(`Exception during parsing: ${e}`);\n                    this._emitEnd({ error, incomplete: false });\n                }\n            }\n        };\n        const readHeaderChunk = () => {\n            // Wait for enough bytes for us to read the header\n            if (!this._tryEnsureRemaining(1072))\n                return;\n            // Once we've read the header, remove this handler\n            stream.off(\"data\", readHeaderChunk);\n            const cancelled = this._parseHeader();\n            if (!cancelled)\n                stream.on(\"data\", readPacketChunk);\n        };\n        stream.on(\"data\", onReceiveChunk);\n        stream.on(\"data\", readHeaderChunk);\n        stream.on(\"error\", e => {\n            stream.off(\"data\", onReceiveChunk);\n            this._emitEnd({ error: e, incomplete: false });\n        });\n        stream.on(\"end\", () => {\n            var _a;\n            const fullyConsumed = \n            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n            ((_a = this._bytebuf) === null || _a === void 0 ? void 0 : _a.remaining()) === 0 && this._chunks.length === 0;\n            if (fullyConsumed)\n                return;\n            this._emitEnd({ incomplete: true });\n        });\n    }\n    parse(buffer) {\n        this._hasEnded = false;\n        this._bytebuf = ByteBuffer.wrap(buffer, true);\n        const cancelled = this._parseHeader();\n        if (!cancelled)\n            timers.setTimeout(this._parseRecurse.bind(this), 0);\n    }\n    /**\n     * Cancel the current parse operation.\n     */\n    cancel() {\n        if (this._immediateTimerToken) {\n            timers.clearImmediate(this._immediateTimerToken);\n            this._immediateTimerToken = null;\n        }\n        if (this._timeoutTimerToken) {\n            timers.clearTimeout(this._timeoutTimerToken);\n            this._timeoutTimerToken = null;\n        }\n    }\n    /**\n     * Set encryption key for decrypting `svc_EncryptedData` packets.\n     * This allows decryption of messages from public matchmaking, like\n     * chat messages and caster voice data.\n     *\n     * The key can be extracted from `match730_*.dem.info` files with `extractPublicEncryptionKey`.\n     *\n     * @param publicKey Public encryption key.\n     */\n    setEncryptionKey(publicKey) {\n        if (publicKey != null && publicKey.length !== 16) {\n            throw new Error(`Public key must be 16 bytes long, got ${publicKey.length} bytes instead`);\n        }\n        this._encryptionKey = publicKey;\n    }\n    _emitEnd(e) {\n        if (this._hasEnded)\n            return;\n        if (e.error) {\n            this.emit(\"error\", e.error);\n        }\n        this.emit(\"end\", e);\n        this._hasEnded = true;\n    }\n    _parseHeader() {\n        this.header = parseHeaderBytebuf(this._bytebuf);\n        // #65: Some demos are missing playbackTicks from the header\n        if (this.header.playbackTicks > 0) {\n            this.tickInterval = this.header.playbackTime / this.header.playbackTicks;\n        }\n        // If this is a POV demo, try to figure out who the recording player is\n        if (this.header.clientName !== \"GOTV Demo\") {\n            this.stringTables.on(\"update\", this._handleStringTableUpdate.bind(this));\n        }\n        let cancelled = false;\n        this.emit(\"start\", {\n            cancel: () => {\n                cancelled = true;\n            }\n        });\n        return cancelled;\n    }\n    _readIBytes() {\n        this._ensureRemaining(4);\n        const length = this._bytebuf.readInt32();\n        this._ensureRemaining(length);\n        return this._bytebuf.readBytes(length);\n    }\n    _handleEncryptedData(msg) {\n        if (msg.keyType !== 2 || this._encryptionKey == null)\n            return true;\n        const key = new icekey_1.IceKey(2);\n        key.set(this._encryptionKey);\n        assert(msg.encrypted.length % key.blockSize() === 0);\n        const plainText = new Uint8Array(msg.encrypted.length);\n        key.decryptUint8Array(msg.encrypted, plainText);\n        // Create a ByteBuffer skipped past the padding\n        const buf = ByteBuffer.wrap(plainText, true);\n        const paddingBytes = buf.readUint8();\n        if (paddingBytes + 4 > buf.remaining())\n            return false;\n        buf.skip(paddingBytes);\n        // For some reason, the size is encoded as an int32, then as a varint32\n        buf.BE();\n        const bytesWritten = buf.readInt32();\n        buf.LE();\n        if (buf.remaining() !== bytesWritten)\n            return false;\n        const cmd = buf.readVarint32();\n        const size = buf.readVarint32();\n        if (buf.remaining() !== size)\n            return false;\n        const message = net.findByType(cmd);\n        assert(message != null, `No message handler for ${cmd}`);\n        if (this.listenerCount(message.name)) {\n            const msgInst = message.class.decode(new Uint8Array(buf.toBuffer()));\n            this.emit(message.name, msgInst);\n        }\n        return true;\n    }\n    _handleStringTableUpdate(update) {\n        if (this.recordingClientSlot != null)\n            return;\n        if (update.table.name === \"userinfo\" && update.userData != null) {\n            const playerInfo = update.userData;\n            if (playerInfo.name === this.header.clientName) {\n                this.recordingClientSlot = update.entryIndex;\n            }\n        }\n    }\n    /**\n     * Fired when a packet of this type is hit. `svc_MessageName` events are also fired.\n     * @public\n     * @event DemoFile#net_MessageName\n     */\n    _handleDemoPacket() {\n        if (!this._isBroadcastFragment) {\n            this._ensureRemaining(160);\n            // skip cmd info\n            this._bytebuf.skip(152);\n            // skip over sequence info\n            this._bytebuf.readInt32();\n            this._bytebuf.readInt32();\n        }\n        const chunk = this._readIBytes();\n        while (chunk.remaining()) {\n            const cmd = chunk.readVarint32();\n            const size = chunk.readVarint32();\n            const message = net.findByType(cmd);\n            assert(message != null, `No message handler for ${cmd}`);\n            if (this.listenerCount(message.name)) {\n                const messageBuffer = chunk.readBytes(size);\n                const msgInst = message.class.decode(new Uint8Array(messageBuffer.toBuffer()));\n                this.emit(message.name, msgInst);\n            }\n            else {\n                chunk.skip(size);\n            }\n        }\n    }\n    _handleDataChunk() {\n        this._readIBytes();\n    }\n    _handleDataTables() {\n        const chunk = this._isBroadcastFragment\n            ? this._bytebuf\n            : this._readIBytes();\n        this.entities.handleDataTables(chunk);\n    }\n    _handleUserCmd() {\n        this._ensureRemaining(4);\n        this._bytebuf.readInt32(); // outgoing sequence\n        const chunk = this._readIBytes();\n        // If nobody's listening, don't waste cycles decoding it\n        if (!this.listenerCount(\"usercmd\"))\n            return;\n        const bitbuf = bitbuffer_1.BitStream.from(chunk.buffer.slice(chunk.offset, chunk.limit));\n        const move = {\n            commandNumber: 0,\n            tickCount: 0,\n            viewAngles: { x: 0, y: 0, z: 0 },\n            aimDirection: { x: 0, y: 0, z: 0 },\n            forwardMove: 0,\n            sideMove: 0,\n            upMove: 0,\n            buttons: new Array(),\n            impulse: 0,\n            weaponSelect: 0,\n            weaponSubType: 0,\n            randomSeed: 0,\n            mouseDeltaX: 0,\n            mouseDeltaY: 0\n        };\n        if (bitbuf.readOneBit()) {\n            move.commandNumber = bitbuf.readUInt32();\n        }\n        else {\n            move.commandNumber = 1;\n        }\n        if (bitbuf.readOneBit()) {\n            move.tickCount = bitbuf.readUInt32();\n        }\n        else {\n            move.tickCount = 1;\n        }\n        // Read direction\n        if (bitbuf.readOneBit())\n            move.viewAngles.x = bitbuf.readFloat32();\n        if (bitbuf.readOneBit())\n            move.viewAngles.y = bitbuf.readFloat32();\n        if (bitbuf.readOneBit())\n            move.viewAngles.z = bitbuf.readFloat32();\n        // Read aim direction\n        if (bitbuf.readOneBit())\n            move.aimDirection.x = bitbuf.readFloat32();\n        if (bitbuf.readOneBit())\n            move.aimDirection.y = bitbuf.readFloat32();\n        if (bitbuf.readOneBit())\n            move.aimDirection.z = bitbuf.readFloat32();\n        // Read movement\n        if (bitbuf.readOneBit())\n            move.forwardMove = bitbuf.readFloat32();\n        if (bitbuf.readOneBit())\n            move.sideMove = bitbuf.readFloat32();\n        if (bitbuf.readOneBit())\n            move.upMove = bitbuf.readFloat32();\n        if (bitbuf.readOneBit()) {\n            const buttons = bitbuf.readUInt32();\n            if (buttons & (1 << 0))\n                move.buttons.push(\"attack\");\n            if (buttons & (1 << 1))\n                move.buttons.push(\"jump\");\n            if (buttons & (1 << 2))\n                move.buttons.push(\"duck\");\n            if (buttons & (1 << 3))\n                move.buttons.push(\"forward\");\n            if (buttons & (1 << 4))\n                move.buttons.push(\"back\");\n            if (buttons & (1 << 5))\n                move.buttons.push(\"use\");\n            if (buttons & (1 << 6))\n                move.buttons.push(\"cancel\");\n            if (buttons & (1 << 7))\n                move.buttons.push(\"left\");\n            if (buttons & (1 << 8))\n                move.buttons.push(\"right\");\n            if (buttons & (1 << 9))\n                move.buttons.push(\"moveleft\");\n            if (buttons & (1 << 10))\n                move.buttons.push(\"moveright\");\n            if (buttons & (1 << 11))\n                move.buttons.push(\"attack2\");\n            if (buttons & (1 << 12))\n                move.buttons.push(\"run\");\n            if (buttons & (1 << 13))\n                move.buttons.push(\"reload\");\n            if (buttons & (1 << 14))\n                move.buttons.push(\"alt1\");\n            if (buttons & (1 << 15))\n                move.buttons.push(\"alt2\");\n            if (buttons & (1 << 16))\n                move.buttons.push(\"score\");\n            if (buttons & (1 << 17))\n                move.buttons.push(\"speed\");\n            if (buttons & (1 << 18))\n                move.buttons.push(\"walk\");\n            if (buttons & (1 << 19))\n                move.buttons.push(\"zoom\");\n            if (buttons & (1 << 20))\n                move.buttons.push(\"weapon1\");\n            if (buttons & (1 << 21))\n                move.buttons.push(\"weapon2\");\n            if (buttons & (1 << 22))\n                move.buttons.push(\"bullrush\");\n            if (buttons & (1 << 23))\n                move.buttons.push(\"grenade1\");\n            if (buttons & (1 << 24))\n                move.buttons.push(\"grenade2\");\n            if (buttons & (1 << 25))\n                move.buttons.push(\"lookspin\");\n        }\n        if (bitbuf.readOneBit())\n            move.impulse = bitbuf.readUInt8();\n        if (bitbuf.readOneBit()) {\n            move.weaponSelect = bitbuf.readUBits(consts_1.MAX_EDICT_BITS);\n            if (bitbuf.readOneBit())\n                move.weaponSubType = bitbuf.readUBits(6);\n        }\n        if (bitbuf.readOneBit())\n            move.mouseDeltaX = bitbuf.readInt16();\n        if (bitbuf.readOneBit())\n            move.mouseDeltaY = bitbuf.readInt16();\n        this.emit(\"usercmd\", move);\n    }\n    _handleStringTables() {\n        const chunk = this._readIBytes();\n        const bitbuf = bitbuffer_1.BitStream.from(chunk.buffer.slice(chunk.offset, chunk.limit));\n        this.stringTables.handleStringTables(bitbuf);\n    }\n    _tryEnsureRemaining(bytes) {\n        const remaining = this._bytebuf.remaining();\n        if (remaining >= bytes)\n            return true;\n        let left = bytes - remaining;\n        for (let i = 0; i < this._chunks.length && left > 0; ++i)\n            left -= this._chunks[i].length;\n        // We don't have enough bytes with what we have buffered up\n        if (left > 0)\n            return false;\n        const mark = Math.max(0, this._bytebuf.markedOffset);\n        const newOffset = this._bytebuf.offset - mark;\n        // Reset to the marked offset. We're never going to need the bytes preceding it\n        this._bytebuf.offset = mark;\n        this._bytebuf = ByteBuffer.wrap(Buffer.concat([\n            new Uint8Array(this._bytebuf.toBuffer()),\n            ...this._chunks\n        ]), true);\n        this._chunks = [];\n        // Advance to the point we'd already read up to\n        this._bytebuf.offset = newOffset;\n        return true;\n    }\n    _ensureRemaining(bytes) {\n        if (!this._tryEnsureRemaining(bytes)) {\n            throw new RangeError(`Not enough data to continue parsing. ${bytes} bytes needed`);\n        }\n    }\n    _readCommand() {\n        this._ensureRemaining(6);\n        const command = this._bytebuf.readUint8();\n        const tick = this._bytebuf.readInt32();\n        this.playerSlot = this._bytebuf.readUint8();\n        if (tick !== this.currentTick) {\n            this.emit(\"tickend\", this.currentTick);\n            this.currentTick = tick;\n            this.emit(\"tickstart\", this.currentTick);\n        }\n        switch (command) {\n            case 2 /* DemoCommands.Packet */:\n            case 1 /* DemoCommands.Signon */:\n                this._handleDemoPacket();\n                break;\n            case 6 /* DemoCommands.DataTables */:\n                this._handleDataTables();\n                break;\n            case 9 /* DemoCommands.StringTables */:\n                this._handleStringTables();\n                break;\n            case 4 /* DemoCommands.ConsoleCmd */: // TODO\n                this._handleDataChunk();\n                break;\n            case 5 /* DemoCommands.UserCmd */:\n                this._handleUserCmd();\n                break;\n            case 7 /* DemoCommands.Stop */:\n                this.cancel();\n                this.emit(\"tickend\", this.currentTick);\n                this._emitEnd({ incomplete: false });\n                return;\n            case 8 /* DemoCommands.CustomData */:\n                throw new Error(\"Custom data not supported\");\n            case 3 /* DemoCommands.SyncTick */:\n                break;\n            default:\n                throw new Error(`Unrecognised command: ${command}`);\n        }\n    }\n    _parseRecurse() {\n        const now = Date.now();\n        // Schedule another round of parsing\n        if (now - this._lastThreadYieldTime < 32) {\n            this._immediateTimerToken = timers.setImmediate(this._parseRecurse.bind(this));\n        }\n        else {\n            this._lastThreadYieldTime = now;\n            this._timeoutTimerToken = timers.setTimeout(this._parseRecurse.bind(this), 0);\n        }\n        try {\n            this.emit(\"progress\", this._bytebuf.offset / this._bytebuf.limit);\n            this._readCommand();\n        }\n        catch (e) {\n            // Always cancel if we have an error - we've already scheduled the next tick\n            this.cancel();\n            // #11, #172: Some demos have been written incompletely.\n            // Don't throw an error when we run out of bytes to read.\n            if (e instanceof RangeError &&\n                this.header.playbackTicks === 0 &&\n                this.header.playbackTime === 0 &&\n                this.header.playbackFrames === 0) {\n                this._emitEnd({ incomplete: true });\n            }\n            else {\n                const error = e instanceof Error ? e : new Error(`Exception during parsing: ${e}`);\n                this._emitEnd({ error, incomplete: false });\n            }\n        }\n    }\n}\nexports.DemoFile = DemoFile;\n//# sourceMappingURL=demo.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Entities = void 0;\nconst assert = require(\"assert\");\nconst events_1 = require(\"events\");\nconst assert_exists_1 = require(\"./assert-exists\");\nconst bitbuffer_1 = require(\"./ext/bitbuffer\");\nconst consts = require(\"./consts\");\nconst net = require(\"./net\");\nconst immutable = require(\"immutable\");\nconst iter_tools_1 = require(\"iter-tools\");\nconst baseentity_1 = require(\"./entities/baseentity\");\nconst gamerules_1 = require(\"./entities/gamerules\");\nconst networkable_1 = require(\"./entities/networkable\");\nconst player_1 = require(\"./entities/player\");\nconst team_1 = require(\"./entities/team\");\nconst weapon_1 = require(\"./entities/weapon\");\nconst props_1 = require(\"./props\");\nconst Long = require(\"long\");\nconst projectile_1 = require(\"./entities/projectile\");\nfunction isPropExcluded(excludes, table, prop) {\n    return excludes.find(excluded => table.netTableName === excluded.dtName &&\n        prop.varName === excluded.varName);\n}\nfunction readFieldIndex(entityBitBuffer, lastIndex, newWay) {\n    if (newWay && entityBitBuffer.readOneBit()) {\n        return lastIndex + 1;\n    }\n    let ret = 0;\n    if (newWay && entityBitBuffer.readOneBit()) {\n        ret = entityBitBuffer.readUBits(3);\n    }\n    else {\n        ret = entityBitBuffer.readUBits(7);\n        switch (ret & (32 | 64)) {\n            case 32:\n                ret = (ret & ~96) | (entityBitBuffer.readUBits(2) << 5);\n                assert(ret >= 32);\n                break;\n            case 64:\n                ret = (ret & ~96) | (entityBitBuffer.readUBits(4) << 5);\n                assert(ret >= 128);\n                break;\n            case 96:\n                ret = (ret & ~96) | (entityBitBuffer.readUBits(7) << 5);\n                assert(ret >= 512);\n                break;\n        }\n    }\n    if (ret === 0xfff) {\n        // end marker is 4095 for CS:GO\n        return -1;\n    }\n    return lastIndex + 1 + ret;\n}\nfunction cloneProps(props) {\n    const result = {};\n    // eslint-disable-next-line no-restricted-syntax\n    for (const tableName in props) {\n        const oldTable = props[tableName];\n        const newTable = {};\n        // eslint-disable-next-line no-restricted-syntax\n        for (const prop in oldTable) {\n            newTable[prop] = oldTable[prop];\n        }\n        result[tableName] = newTable;\n    }\n    return result;\n}\n/**\n * Represents entities and networked properties within a demo.\n */\nclass Entities extends events_1.EventEmitter {\n    constructor() {\n        super(...arguments);\n        this.dataTables = [];\n        this.serverClasses = [];\n        /**\n         * Map of entity index => networkable instance\n         */\n        this.entities = new Map();\n        this.markedForDeletion = [];\n        this.staticBaselines = {};\n        this.pendingBaselines = {};\n        this.serverClassBits = 0;\n        this.tableClassMap = {\n            DT_CSPlayer: player_1.Player,\n            DT_Team: team_1.Team,\n            DT_CSGameRules: gamerules_1.GameRules,\n            DT_BaseCSGrenadeProjectile: projectile_1.Projectile,\n            DT_WeaponCSBase: weapon_1.Weapon,\n            DT_BaseEntity: baseentity_1.BaseEntity\n        };\n        this._serverClassConstructor = new Map();\n        /**\n         * Set of which entities were active in the most recent tick.\n         */\n        this.transmitEntities = null;\n        this._entityBaselines = [\n            new Map(),\n            new Map()\n        ];\n        this._frames = immutable.Map();\n        this._demo = null;\n        this._singletonEnts = {};\n        this._currentServerTick = -1;\n        this._maxPlayers = 0;\n        this._userInfoTable = null;\n        this._userIdToEntity = new Map();\n        this._steam64IdToEntity = new Map();\n        this._accountNumberToEntity = new Map();\n    }\n    get playerResource() {\n        return this._demo.entities.getSingleton(\"CCSPlayerResource\");\n    }\n    get gameRules() {\n        return this.getSingleton(\"CCSGameRulesProxy\");\n    }\n    get teams() {\n        return Array.from(this.findAllWithClass(team_1.Team));\n    }\n    get players() {\n        const players = [];\n        for (let i = 1; i <= this._maxPlayers; ++i) {\n            const entity = this.entities.get(i);\n            // Only return players that are fully connected\n            if ((entity === null || entity === void 0 ? void 0 : entity.userInfo) != null) {\n                players.push(entity);\n            }\n        }\n        return players;\n    }\n    get weapons() {\n        return Array.from(this.findAllWithClass(weapon_1.Weapon));\n    }\n    listen(demo) {\n        this._demo = demo;\n        demo.on(\"svc_PacketEntities\", e => this._handlePacketEntities(e));\n        demo.on(\"svc_TempEntities\", e => this._handleTempEntities(e));\n        demo.on(\"svc_ServerInfo\", e => {\n            this._maxPlayers = e.maxClients;\n        });\n        demo.on(\"net_Tick\", e => {\n            this._currentServerTick = e.tick;\n        });\n        demo.stringTables.on(\"create\", table => {\n            if (table.name === \"userinfo\")\n                this._userInfoTable = table;\n        });\n        demo.stringTables.on(\"update\", e => this._handleStringTableUpdate(e));\n        demo.on(\"tickend\", () => {\n            if (this.markedForDeletion.length > 0) {\n                for (const index of this.markedForDeletion) {\n                    this.entities.delete(index);\n                    this.emit(\"remove\", { index });\n                }\n                this.markedForDeletion.length = 0;\n            }\n        });\n    }\n    /**\n     * Determines whether handle is set.\n     * This function does not determine whether the handle points to a valid entity.\n     * @param {number} handle - Networked entity handle value\n     * @returns {boolean} true if handle is set\n     */\n    isHandleSet(handle) {\n        return handle !== consts.INVALID_NETWORKED_EHANDLE_VALUE;\n    }\n    /**\n     * Returns the entity specified by a particular handle.\n     * @param {number} handle - Networked entity handle value\n     * @returns {Entity|null} Entity referenced by the handle. `null` if no matching entity.\n     */\n    getByHandle(handle) {\n        if (!handle.isValid) {\n            return null;\n        }\n        const ent = this.entities.get(handle.index);\n        if (ent == null || ent.serialNum !== handle.serialNum) {\n            return null;\n        }\n        return ent;\n    }\n    /**\n     * Returns the entity that belongs to the player with a given user ID.\n     * @param {number} userId - Player user ID\n     * @returns {Player|null} Entity referenced by the user ID. `null` if no matching player.\n     */\n    getByUserId(userId) {\n        const entityIndex = this._userIdToEntity.get(userId);\n        if (entityIndex === undefined)\n            return null;\n        return this.entities.get(entityIndex);\n    }\n    /**\n     * Returns the entity that belongs to the player with a given Steam account ID.\n     * @param {number} accountId - Steam account ID\n     * @returns {Player|null} Entity referenced by the account ID. `null` if no matching player.\n     */\n    getByAccountId(accountId) {\n        const entityIndex = this._accountNumberToEntity.get(accountId);\n        if (entityIndex === undefined)\n            return null;\n        return this.entities.get(entityIndex);\n    }\n    /**\n     * Returns the entity that belongs to the player with a given 64-bit Steam ID.\n     * @param {Long|string} steam64Id - 64-bit Steam ID\n     * @returns {Player|null} Entity referenced by the Steam ID. `null` if no matching player.\n     */\n    getBySteam64Id(steam64Id) {\n        const idString = steam64Id instanceof Long ? steam64Id.toString() : steam64Id;\n        const entityIndex = this._steam64IdToEntity.get(idString);\n        if (entityIndex === undefined)\n            return null;\n        return this.entities.get(entityIndex);\n    }\n    getSingleton(serverClass) {\n        const existing = this._singletonEnts[serverClass];\n        if (existing) {\n            return existing;\n        }\n        const result = (0, iter_tools_1.find)(([, ent]) => ent.serverClass.name === serverClass, this.entities);\n        if (!result) {\n            throw new Error(`Missing singleton ${serverClass}`);\n        }\n        const [, entity] = result;\n        this._singletonEnts[serverClass] = entity;\n        return entity;\n    }\n    *findAllWithTable(table) {\n        for (const ent of this.entities.values()) {\n            if (table in ent.props) {\n                yield ent;\n            }\n        }\n    }\n    *findAllWithClass(klass) {\n        for (const ent of this.entities.values()) {\n            if (ent instanceof klass) {\n                yield ent;\n            }\n        }\n    }\n    handleDataTables(chunk) {\n        // eslint-disable-next-line no-constant-condition\n        while (true) {\n            const descriptor = net.findByType(chunk.readVarint32());\n            assert((descriptor === null || descriptor === void 0 ? void 0 : descriptor.name) === \"svc_SendTable\", \"expected SendTable message\");\n            const length = chunk.readVarint32();\n            const msg = descriptor.class.decode(new Uint8Array(chunk.readBytes(length).toBuffer()));\n            if (msg.isEnd) {\n                break;\n            }\n            this.dataTables.push(msg);\n        }\n        const serverClasses = chunk.readShort();\n        this.serverClassBits = Math.ceil(Math.log2(serverClasses));\n        for (let i = 0; i < serverClasses; ++i) {\n            const classId = chunk.readShort();\n            assert(classId === i, \"server class entry for invalid class ID\");\n            const name = chunk.readCString();\n            const dtName = chunk.readCString();\n            const dataTable = (0, assert_exists_1.default)(this._findTableByName(dtName), \"no data table for server class\");\n            const serverClass = {\n                name,\n                dtName,\n                dataTable,\n                flattenedProps: this._flattenDataTable(dataTable)\n            };\n            this.serverClasses.push(serverClass);\n            // Find the constructor for this server class\n            const tablesInClass = new Set(serverClass.flattenedProps.map(prop => prop.table.netTableName));\n            // eslint-disable-next-line no-restricted-syntax\n            for (const tableName in this.tableClassMap) {\n                if (tablesInClass.has(tableName)) {\n                    this._serverClassConstructor.set(classId, this.tableClassMap[tableName]);\n                    break;\n                }\n            }\n            // parse any pending baseline\n            const pendingBaseline = this.pendingBaselines[classId];\n            if (pendingBaseline) {\n                this.staticBaselines[classId] = this._parseInstanceBaseline(pendingBaseline, classId);\n                this.emit(\"baselineupdate\", {\n                    classId,\n                    serverClass,\n                    baseline: this.staticBaselines[classId]\n                });\n                delete this.pendingBaselines[classId];\n            }\n        }\n        this.emit(\"datatablesready\");\n    }\n    _gatherExcludes(table) {\n        const excludes = [];\n        for (const prop of table.props) {\n            if ((prop.flags & props_1.SPROP_EXCLUDE) !== 0) {\n                excludes.push(prop);\n            }\n            if (prop.type === 6 /* PropType.DataTable */) {\n                const subTable = (0, assert_exists_1.default)(this._findTableByName(prop.dtName));\n                excludes.push(...this._gatherExcludes(subTable));\n            }\n        }\n        return excludes;\n    }\n    _gatherProps(table, excludes) {\n        const flattened = [];\n        for (let index = 0; index < table.props.length; ++index) {\n            const prop = table.props[index];\n            if ((prop.flags & props_1.SPROP_INSIDEARRAY) !== 0 ||\n                (prop.flags & props_1.SPROP_EXCLUDE) !== 0 ||\n                isPropExcluded(excludes, table, prop)) {\n                continue;\n            }\n            if (prop.type === 6 /* PropType.DataTable */) {\n                const subTable = (0, assert_exists_1.default)(this._findTableByName(prop.dtName));\n                const childProps = this._gatherProps(subTable, excludes);\n                if ((prop.flags & props_1.SPROP_COLLAPSIBLE) === 0) {\n                    for (const fp of childProps) {\n                        fp.collapsible = false;\n                    }\n                }\n                flattened.push(...childProps);\n            }\n            else {\n                flattened.push({\n                    prop,\n                    table,\n                    decode: (0, props_1.makeDecoder)(prop, prop.type === 5 /* PropType.Array */ ? table.props[index - 1] : undefined),\n                    collapsible: true\n                });\n            }\n        }\n        // collapsible props should come after non-collapsible\n        return flattened.sort(({ collapsible: a }, { collapsible: b }) => (a ? 1 : 0) - (b ? 1 : 0));\n    }\n    _flattenDataTable(table) {\n        const flattenedProps = this._gatherProps(table, this._gatherExcludes(table));\n        const prioritySet = new Set(flattenedProps.map(fp => fp.prop.priority));\n        prioritySet.add(64);\n        const priorities = Array.from(prioritySet).sort((a, b) => a - b);\n        let start = 0;\n        // On this surface this looks like a sort by priority (or min(64, priority)\n        // for CHANGES_OFTEN props). It's not a stable sort so it can't just be\n        // replaced with JS Array#sort\n        for (const priority of priorities) {\n            // eslint-disable-next-line no-constant-condition\n            while (true) {\n                let currentProp;\n                for (currentProp = start; currentProp < flattenedProps.length; ++currentProp) {\n                    const prop = flattenedProps[currentProp].prop;\n                    if (prop.priority === priority ||\n                        (priority === 64 && (prop.flags & props_1.SPROP_CHANGES_OFTEN) !== 0)) {\n                        if (start !== currentProp) {\n                            const temp = flattenedProps[start];\n                            flattenedProps[start] = flattenedProps[currentProp];\n                            flattenedProps[currentProp] = temp;\n                        }\n                        start++;\n                        break;\n                    }\n                }\n                if (currentProp === flattenedProps.length) {\n                    break;\n                }\n            }\n        }\n        return flattenedProps;\n    }\n    _findTableByName(name) {\n        return this.dataTables.find(table => table.netTableName === name);\n    }\n    _addEntity(index, classId, serialNum, existingEntity, entityBaseline) {\n        const baseline = entityBaseline || this.staticBaselines[classId];\n        if (!baseline) {\n            throw new Error(`no baseline for entity ${index} (class ID ${classId})`);\n        }\n        const props = cloneProps(baseline);\n        // If we already have this entity, start fresh with baseline props\n        if ((existingEntity === null || existingEntity === void 0 ? void 0 : existingEntity.serialNum) === serialNum) {\n            existingEntity.props = props;\n            return existingEntity;\n        }\n        // Delete the entity if the serial numbers mismatch\n        if (existingEntity) {\n            this._removeEntity(index, true);\n        }\n        const klass = this._serverClassConstructor.get(classId) || networkable_1.Networkable;\n        const entity = new klass(this._demo, index, classId, serialNum, props);\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n        this.entities.set(index, entity);\n        return entity;\n    }\n    _removeEntity(index, immediate) {\n        const entity = this.entities.get(index);\n        if (!entity) {\n            return;\n        }\n        // It's possible that the entity is already marked for deletion.\n        // This is because entities are deleted at the end of the dem_packet,\n        // after the game events fire.\n        if (!immediate && entity.deleting) {\n            return;\n        }\n        this.emit(\"beforeremove\", { entity, immediate });\n        if (immediate) {\n            this.entities.delete(index);\n            this.emit(\"remove\", { index });\n        }\n        else {\n            entity.deleting = true;\n            this.markedForDeletion.push(index);\n        }\n    }\n    _parseEntityUpdate(entityBitBuffer, classId) {\n        const serverClass = this.serverClasses[classId];\n        const newWay = entityBitBuffer.readOneBit();\n        let lastIndex = -1;\n        const fieldIndices = [];\n        // eslint-disable-next-line no-constant-condition\n        while (true) {\n            lastIndex = readFieldIndex(entityBitBuffer, lastIndex, newWay);\n            if (lastIndex === -1) {\n                break;\n            }\n            fieldIndices.push(lastIndex);\n        }\n        const updatedProps = new Array(fieldIndices.length);\n        for (let i = 0; i < fieldIndices.length; ++i) {\n            const propIndex = fieldIndices[i];\n            const flattenedProp = serverClass.flattenedProps[propIndex];\n            assert(flattenedProp);\n            updatedProps[i] = {\n                prop: flattenedProp,\n                value: flattenedProp.decode(entityBitBuffer)\n            };\n        }\n        return updatedProps;\n    }\n    _readNewEntity(entityBitBuffer, entity) {\n        const updates = this._parseEntityUpdate(entityBitBuffer, entity.classId);\n        const recordChanges = this.listenerCount(\"change\") > 0;\n        const changes = recordChanges\n            ? new Array(updates.length)\n            : [];\n        for (let i = 0; i < updates.length; ++i) {\n            const update = updates[i];\n            const tableName = update.prop.table.netTableName;\n            const varName = update.prop.prop.varName;\n            const table = entity.props[tableName];\n            const oldValue = table && varName in table ? table[varName] : undefined;\n            entity.updateProp(tableName, varName, update.value);\n            if (recordChanges) {\n                changes[i] = {\n                    tableName,\n                    varName,\n                    oldValue,\n                    newValue: update.value\n                };\n            }\n        }\n        if (recordChanges) {\n            this.emit(\"change\", {\n                entity,\n                changes\n            });\n        }\n    }\n    _updatesToPropObject(target, updates) {\n        for (const update of updates) {\n            const tableName = update.prop.table.netTableName;\n            const varName = update.prop.prop.varName;\n            target[tableName] = Object.assign(target[tableName] || {}, {\n                [varName]: update.value\n            });\n        }\n        return target;\n    }\n    _handleTempEntities(msg) {\n        const entityBitBuffer = bitbuffer_1.BitStream.from(msg.entityData);\n        let lastClassId = -1;\n        let lastProps = null;\n        // Reliable tempents are sent with 0 entries, but really they have 1\n        const numEntries = msg.numEntries === 0 ? 1 : msg.numEntries;\n        for (let i = 0; i < numEntries; ++i) {\n            let fireDelay = 0.0;\n            if (entityBitBuffer.readOneBit()) {\n                fireDelay = entityBitBuffer.readSBits(8) / 100.0;\n            }\n            if (entityBitBuffer.readOneBit()) {\n                lastClassId = entityBitBuffer.readUBits(this.serverClassBits) - 1;\n                const updates = this._parseEntityUpdate(entityBitBuffer, lastClassId);\n                lastProps = this._updatesToPropObject({}, updates);\n            }\n            else {\n                // delta against last temp entity\n                assert(lastClassId !== -1, \"Delta with no baseline\");\n                const updates = this._parseEntityUpdate(entityBitBuffer, lastClassId);\n                lastProps = this._updatesToPropObject(cloneProps((0, assert_exists_1.default)(lastProps)), updates);\n            }\n            this.emit(\"tempent\", {\n                delay: fireDelay,\n                classId: lastClassId,\n                serverClass: this.serverClasses[lastClassId],\n                props: lastProps\n            });\n        }\n    }\n    _handlePacketEntities(msg) {\n        // Take a copy of the transmitted entities from the delta frame\n        // Otherwise start with a blank slate\n        const baseTransmitEntities = (0, assert_exists_1.default)(msg.isDelta\n            ? this._frames.get(msg.deltaFrom)\n            : immutable.Set(), `delta from unknown frame ${msg.deltaFrom}`);\n        if (!msg.isDelta) {\n            // Clear out old entities - this is a full update\n            for (const entityIndex of Array.from(this.entities.keys())) {\n                this._removeEntity(entityIndex, true);\n            }\n            // Remove all frames - we won't be using them\n            this._frames = immutable.Map();\n            // Clear all entity baselines\n            for (const baseline of this._entityBaselines) {\n                baseline.clear();\n            }\n        }\n        const newFrame = baseTransmitEntities.withMutations(mutableFrame => this._readPacketEntities(msg, mutableFrame));\n        this._frames = this._frames.set(this._currentServerTick, newFrame);\n        this.transmitEntities = newFrame;\n        // Delete old frames that we no longer need to reference\n        if (msg.isDelta) {\n            const oldFrames = (0, iter_tools_1.filter)(tick => tick < msg.deltaFrom, this._frames.keys());\n            this._frames = this._frames.removeAll(oldFrames);\n        }\n    }\n    _readPacketEntities(msg, frame) {\n        const entityBitBuffer = bitbuffer_1.BitStream.from(msg.entityData);\n        let entityIndex = -1;\n        for (let i = 0; i < msg.updatedEntries; ++i) {\n            entityIndex += 1 + entityBitBuffer.readUBitVar();\n            assert(entityIndex < consts.MAX_EDICTS, \"newEntity >= MAX_EDICTS\");\n            if (entityBitBuffer.readOneBit()) {\n                assert(msg.isDelta, \"entity leaving PVS on full update\");\n                frame.remove(entityIndex);\n                if (entityBitBuffer.readOneBit()) {\n                    // 0b11: FHDR_LEAVEPVS | FHDR_DELETE\n                    this._removeEntity(entityIndex, false);\n                }\n                else {\n                    // 0b10: FHDR_LEAVEPVS\n                }\n                // eslint-disable-next-line no-dupe-else-if\n            }\n            else if (entityBitBuffer.readOneBit()) {\n                // 0b01: FHDR_ENTERPVS\n                frame.add(entityIndex);\n                const classId = entityBitBuffer.readUBits(this.serverClassBits);\n                const serialNum = entityBitBuffer.readUBits(consts.NUM_NETWORKED_EHANDLE_SERIAL_NUMBER_BITS);\n                const existingBaseline = this._entityBaselines[msg.baseline].get(entityIndex);\n                const entityBaselineProps = msg.isDelta && (existingBaseline === null || existingBaseline === void 0 ? void 0 : existingBaseline.classId) === classId\n                    ? existingBaseline.props\n                    : undefined;\n                const existingEntity = this.entities.get(entityIndex);\n                const entity = this._addEntity(entityIndex, classId, serialNum, existingEntity, entityBaselineProps);\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n                this._readNewEntity(entityBitBuffer, entity);\n                if (entity !== existingEntity) {\n                    const eventVars = { entity };\n                    this.emit(\"create\", eventVars);\n                    // Still emit 'postcreate' for backwards compatibility\n                    this.emit(\"postcreate\", eventVars);\n                }\n                // Update the OTHER baseline with the merged result of `old baseline + new props`\n                if (msg.updateBaseline) {\n                    this._entityBaselines[msg.baseline ? 0 : 1].set(entityIndex, {\n                        classId,\n                        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n                        props: cloneProps(entity.props)\n                    });\n                }\n            }\n            else {\n                // 0b00: DeltaEnt\n                const entity = (0, assert_exists_1.default)(this.entities.get(entityIndex), `missing client entity ${entityIndex}`);\n                assert(frame.contains(entityIndex), `delta on dormant entity ${entityIndex}`);\n                this._readNewEntity(entityBitBuffer, entity);\n            }\n        }\n        // Read deletions\n        if (msg.isDelta) {\n            entityIndex = -1;\n            const deletions = entityBitBuffer.readUBitVar();\n            for (let i = 0; i < deletions; ++i) {\n                entityIndex += entityBitBuffer.readUBitVar();\n                // Entity wasn't dealt with in packet, but has been deleted\n                frame.remove(entityIndex);\n                this._removeEntity(entityIndex, false);\n            }\n        }\n    }\n    _parseInstanceBaseline(baselineBuf, classId) {\n        const classBaseline = {};\n        for (const bl of this._parseEntityUpdate(baselineBuf, classId)) {\n            const tableName = bl.prop.table.netTableName;\n            const varName = bl.prop.prop.varName;\n            const table = classBaseline[tableName];\n            if (table === undefined) {\n                classBaseline[tableName] = { [varName]: bl.value };\n            }\n            else {\n                table[varName] = bl.value;\n            }\n        }\n        return classBaseline;\n    }\n    _handleUserInfoUpdate(clientSlot, oldPlayerInfo, playerInfo) {\n        if (oldPlayerInfo != null) {\n            this._userIdToEntity.delete(oldPlayerInfo.userId);\n            this._steam64IdToEntity.delete(oldPlayerInfo.xuid.toString());\n            this._accountNumberToEntity.delete(oldPlayerInfo.friendsId);\n        }\n        if (playerInfo != null) {\n            this._userIdToEntity.set(playerInfo.userId, clientSlot + 1);\n            this._steam64IdToEntity.set(playerInfo.xuid.toString(), clientSlot + 1);\n            this._accountNumberToEntity.set(playerInfo.friendsId, clientSlot + 1);\n        }\n    }\n    _handleInstanceBaselineUpdate(event) {\n        if (!event.userData)\n            return;\n        const classId = parseInt(event.entry, 10);\n        const baselineBuf = bitbuffer_1.BitStream.from(event.userData);\n        if (!this.serverClasses[classId]) {\n            this.pendingBaselines[classId] = baselineBuf;\n            return;\n        }\n        const baseline = this._parseInstanceBaseline(baselineBuf, classId);\n        this.staticBaselines[classId] = baseline;\n        this.emit(\"baselineupdate\", {\n            classId,\n            serverClass: this.serverClasses[classId],\n            baseline\n        });\n    }\n    _handleStringTableUpdate(event) {\n        if (event.table.name === \"userinfo\") {\n            this._handleUserInfoUpdate(event.entryIndex, event.oldUserData, event.userData);\n        }\n        else if (event.table.name === \"instancebaseline\") {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n            this._handleInstanceBaselineUpdate(event);\n        }\n    }\n}\nexports.Entities = Entities;\n//# sourceMappingURL=entities.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.BaseEntity = void 0;\nconst networkable_1 = require(\"./networkable\");\n/**\n * Represents an in-game entity.\n */\nclass BaseEntity extends networkable_1.Networkable {\n    /**\n     * Position of this entity in the game world.\n     * @returns World-space coordinates\n     */\n    get position() {\n        const cellWidth = 1 << this.getProp(\"DT_BaseEntity\", \"m_cellbits\");\n        const cellX = this.getProp(\"DT_BaseEntity\", \"m_cellX\");\n        const cellY = this.getProp(\"DT_BaseEntity\", \"m_cellY\");\n        const cellZ = this.getProp(\"DT_BaseEntity\", \"m_cellZ\");\n        const cellOffset = this.getProp(\"DT_BaseEntity\", \"m_vecOrigin\");\n        return {\n            x: cellX * cellWidth - 16384 + cellOffset.x,\n            y: cellY * cellWidth - 16384 + cellOffset.y,\n            z: cellZ * cellWidth - 16384 + cellOffset.z\n        };\n    }\n    /**\n     * @returns Entity which this entity is moving with, if any\n     */\n    get moveParent() {\n        // UNSAFE: cast here as move parent will always be a proper entity\n        return this._demo.entities.getByHandle(this.getProp(\"DT_BaseEntity\", \"moveparent\"));\n    }\n    /**\n     * @returns Owning entity, if any\n     */\n    get owner() {\n        // UNSAFE: cast here as owner will always be a proper entity\n        return this._demo.entities.getByHandle(this.getProp(\"DT_BaseEntity\", \"m_hOwnerEntity\"));\n    }\n    /**\n     * @returns Team number (0: Unassigned, 1: Spectator, 2: Terrorist, 3: Counter-Terrorist)\n     */\n    get teamNumber() {\n        return this.getProp(\"DT_BaseEntity\", \"m_iTeamNum\");\n    }\n    /**\n     * @returns Team if assigned, null if unassigned.\n     */\n    get team() {\n        const teamNum = this.teamNumber;\n        if (teamNum === 0) {\n            return null;\n        }\n        return this._demo.entities.teams[teamNum];\n    }\n    /**\n     * @returns Name of the model that should be rendered for this entity. (e.g. 'models/Weapons/w_eq_smokegrenade_thrown.mdl')\n     */\n    get modelName() {\n        const modelprecache = this._demo.stringTables.findTableByName(\"modelprecache\");\n        if (!modelprecache) {\n            return null;\n        }\n        return modelprecache.entries[this.getProp(\"DT_BaseEntity\", \"m_nModelIndex\")].entry;\n    }\n}\nexports.BaseEntity = BaseEntity;\n//# sourceMappingURL=baseentity.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GameRules = void 0;\nconst networkable_1 = require(\"./networkable\");\n/**\n * Represents the game rules.\n */\nclass GameRules extends networkable_1.Networkable {\n    /**\n     * @returns Is the game currently in 'warmup' mode?\n     */\n    get isWarmup() {\n        return this.getProp(\"DT_CSGameRules\", \"m_bWarmupPeriod\");\n    }\n    /**\n     * @deprecated Use `GameRules#roundsPlayed` instead.\n     */\n    get roundNumber() {\n        return this.roundsPlayed;\n    }\n    /**\n     * This value is incremented when the scores are updated at round end.\n     * If you need to keep track of the current round number, store this value\n     * at each `round_start`.\n     *\n     * @returns Total number of rounds played.\n     */\n    get roundsPlayed() {\n        return this.getProp(\"DT_CSGameRules\", \"m_totalRoundsPlayed\");\n    }\n    /**\n     * @returns 'first', 'second', 'halftime' or 'postgame'\n     */\n    get phase() {\n        const gamePhases = {\n            2: \"first\",\n            3: \"second\",\n            4: \"halftime\",\n            5: \"postgame\"\n        };\n        const phase = this.getProp(\"DT_CSGameRules\", \"m_gamePhase\");\n        return gamePhases[phase];\n    }\n}\nexports.GameRules = GameRules;\n//# sourceMappingURL=gamerules.js.map","\"use strict\";\n// DO NOT MODIFY!\n// Auto-generated by ./generators/itemdefs.ts\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.paintKitIndexMap = exports.itemDefinitionIndexMap = void 0;\nexports.itemDefinitionIndexMap = {\n    \"1\": {\n        className: \"weapon_deagle\",\n        itemName: \"Desert Eagle\"\n    },\n    \"2\": {\n        className: \"weapon_elite\",\n        itemName: \"Dual Berettas\"\n    },\n    \"3\": {\n        className: \"weapon_fiveseven\",\n        itemName: \"Five-SeveN\"\n    },\n    \"4\": {\n        className: \"weapon_glock\",\n        itemName: \"Glock-18\"\n    },\n    \"7\": {\n        className: \"weapon_ak47\",\n        itemName: \"AK-47\"\n    },\n    \"8\": {\n        className: \"weapon_aug\",\n        itemName: \"AUG\"\n    },\n    \"9\": {\n        className: \"weapon_awp\",\n        itemName: \"AWP\"\n    },\n    \"10\": {\n        className: \"weapon_famas\",\n        itemName: \"FAMAS\"\n    },\n    \"11\": {\n        className: \"weapon_g3sg1\",\n        itemName: \"G3SG1\"\n    },\n    \"13\": {\n        className: \"weapon_galilar\",\n        itemName: \"Galil AR\"\n    },\n    \"14\": {\n        className: \"weapon_m249\",\n        itemName: \"M249\"\n    },\n    \"16\": {\n        className: \"weapon_m4a1\",\n        itemName: \"M4A4\"\n    },\n    \"17\": {\n        className: \"weapon_mac10\",\n        itemName: \"MAC-10\"\n    },\n    \"19\": {\n        className: \"weapon_p90\",\n        itemName: \"P90\"\n    },\n    \"20\": {\n        className: \"weapon_zone_repulsor\",\n        itemName: \"Repulsor Device\"\n    },\n    \"23\": {\n        className: \"weapon_mp5sd\",\n        itemName: \"MP5-SD\"\n    },\n    \"24\": {\n        className: \"weapon_ump45\",\n        itemName: \"UMP-45\"\n    },\n    \"25\": {\n        className: \"weapon_xm1014\",\n        itemName: \"XM1014\"\n    },\n    \"26\": {\n        className: \"weapon_bizon\",\n        itemName: \"PP-Bizon\"\n    },\n    \"27\": {\n        className: \"weapon_mag7\",\n        itemName: \"MAG-7\"\n    },\n    \"28\": {\n        className: \"weapon_negev\",\n        itemName: \"Negev\"\n    },\n    \"29\": {\n        className: \"weapon_sawedoff\",\n        itemName: \"Sawed-Off\"\n    },\n    \"30\": {\n        className: \"weapon_tec9\",\n        itemName: \"Tec-9\"\n    },\n    \"31\": {\n        className: \"weapon_taser\",\n        itemName: \"Zeus x27\"\n    },\n    \"32\": {\n        className: \"weapon_hkp2000\",\n        itemName: \"P2000\"\n    },\n    \"33\": {\n        className: \"weapon_mp7\",\n        itemName: \"MP7\"\n    },\n    \"34\": {\n        className: \"weapon_mp9\",\n        itemName: \"MP9\"\n    },\n    \"35\": {\n        className: \"weapon_nova\",\n        itemName: \"Nova\"\n    },\n    \"36\": {\n        className: \"weapon_p250\",\n        itemName: \"P250\"\n    },\n    \"37\": {\n        className: \"weapon_shield\",\n        itemName: \"Riot Shield\"\n    },\n    \"38\": {\n        className: \"weapon_scar20\",\n        itemName: \"SCAR-20\"\n    },\n    \"39\": {\n        className: \"weapon_sg556\",\n        itemName: \"SG 553\"\n    },\n    \"40\": {\n        className: \"weapon_ssg08\",\n        itemName: \"SSG 08\"\n    },\n    \"41\": {\n        className: \"weapon_knifegg\",\n        itemName: \"Knife\"\n    },\n    \"42\": {\n        className: \"weapon_knife\",\n        itemName: \"Knife\"\n    },\n    \"43\": {\n        className: \"weapon_flashbang\",\n        itemName: \"Flashbang\"\n    },\n    \"44\": {\n        className: \"weapon_hegrenade\",\n        itemName: \"High Explosive Grenade\"\n    },\n    \"45\": {\n        className: \"weapon_smokegrenade\",\n        itemName: \"Smoke Grenade\"\n    },\n    \"46\": {\n        className: \"weapon_molotov\",\n        itemName: \"Molotov\"\n    },\n    \"47\": {\n        className: \"weapon_decoy\",\n        itemName: \"Decoy Grenade\"\n    },\n    \"48\": {\n        className: \"weapon_incgrenade\",\n        itemName: \"Incendiary Grenade\"\n    },\n    \"49\": {\n        className: \"weapon_c4\",\n        itemName: \"C4 Explosive\"\n    },\n    \"57\": {\n        className: \"weapon_healthshot\",\n        itemName: \"Medi-Shot\"\n    },\n    \"59\": {\n        className: \"weapon_knife_t\",\n        itemName: \"Knife\"\n    },\n    \"60\": {\n        className: \"weapon_m4a1_silencer\",\n        itemName: \"M4A1-S\"\n    },\n    \"61\": {\n        className: \"weapon_usp_silencer\",\n        itemName: \"USP-S\"\n    },\n    \"63\": {\n        className: \"weapon_cz75a\",\n        itemName: \"CZ75-Auto\"\n    },\n    \"64\": {\n        className: \"weapon_revolver\",\n        itemName: \"R8 Revolver\"\n    },\n    \"68\": {\n        className: \"weapon_tagrenade\",\n        itemName: \"Tactical Awareness Grenade\"\n    },\n    \"69\": {\n        className: \"weapon_fists\",\n        itemName: \"Bare Hands\"\n    },\n    \"70\": {\n        className: \"weapon_breachcharge\",\n        itemName: \"Breach Charge\"\n    },\n    \"72\": {\n        className: \"weapon_tablet\",\n        itemName: \"Tablet\"\n    },\n    \"75\": {\n        className: \"weapon_axe\",\n        itemName: \"Axe\"\n    },\n    \"76\": {\n        className: \"weapon_hammer\",\n        itemName: \"Hammer\"\n    },\n    \"78\": {\n        className: \"weapon_spanner\",\n        itemName: \"Wrench\"\n    },\n    \"80\": {\n        className: \"weapon_knife_ghost\",\n        itemName: \"Knife\"\n    },\n    \"81\": {\n        className: \"weapon_firebomb\",\n        itemName: \"Fire Bomb\"\n    },\n    \"82\": {\n        className: \"weapon_diversion\",\n        itemName: \"Diversion Device\"\n    },\n    \"83\": {\n        className: \"weapon_frag_grenade\",\n        itemName: \"Frag Grenade\"\n    },\n    \"84\": {\n        className: \"weapon_snowball\",\n        itemName: \"Snowball\"\n    },\n    \"85\": {\n        className: \"weapon_bumpmine\",\n        itemName: \"Bump Mine\"\n    },\n    \"500\": {\n        className: \"weapon_bayonet\",\n        itemName: \"Bayonet\"\n    },\n    \"503\": {\n        className: \"weapon_knife_css\",\n        itemName: \"Classic Knife\"\n    },\n    \"505\": {\n        className: \"weapon_knife_flip\",\n        itemName: \"Flip Knife\"\n    },\n    \"506\": {\n        className: \"weapon_knife_gut\",\n        itemName: \"Gut Knife\"\n    },\n    \"507\": {\n        className: \"weapon_knife_karambit\",\n        itemName: \"Karambit\"\n    },\n    \"508\": {\n        className: \"weapon_knife_m9_bayonet\",\n        itemName: \"M9 Bayonet\"\n    },\n    \"509\": {\n        className: \"weapon_knife_tactical\",\n        itemName: \"Huntsman Knife\"\n    },\n    \"512\": {\n        className: \"weapon_knife_falchion\",\n        itemName: \"Falchion Knife\"\n    },\n    \"514\": {\n        className: \"weapon_knife_survival_bowie\",\n        itemName: \"Bowie Knife\"\n    },\n    \"515\": {\n        className: \"weapon_knife_butterfly\",\n        itemName: \"Butterfly Knife\"\n    },\n    \"516\": {\n        className: \"weapon_knife_push\",\n        itemName: \"Shadow Daggers\"\n    },\n    \"517\": {\n        className: \"weapon_knife_cord\",\n        itemName: \"Paracord Knife\"\n    },\n    \"518\": {\n        className: \"weapon_knife_canis\",\n        itemName: \"Survival Knife\"\n    },\n    \"519\": {\n        className: \"weapon_knife_ursus\",\n        itemName: \"Ursus Knife\"\n    },\n    \"520\": {\n        className: \"weapon_knife_gypsy_jackknife\",\n        itemName: \"Navaja Knife\"\n    },\n    \"521\": {\n        className: \"weapon_knife_outdoor\",\n        itemName: \"Nomad Knife\"\n    },\n    \"522\": {\n        className: \"weapon_knife_stiletto\",\n        itemName: \"Stiletto Knife\"\n    },\n    \"523\": {\n        className: \"weapon_knife_widowmaker\",\n        itemName: \"Talon Knife\"\n    },\n    \"525\": {\n        className: \"weapon_knife_skeleton\",\n        itemName: \"Skeleton Knife\"\n    }\n};\nexports.paintKitIndexMap = {\n    \"0\": {\n        name: \"default\",\n        tag: \"-\"\n    },\n    \"2\": {\n        name: \"so_olive\",\n        tag: \"Groundwater\"\n    },\n    \"3\": {\n        name: \"so_red\",\n        tag: \"Candy Apple\"\n    },\n    \"5\": {\n        name: \"hy_ddpat\",\n        tag: \"Forest DDPAT\"\n    },\n    \"6\": {\n        name: \"hy_arctic\",\n        tag: \"Arctic Camo\"\n    },\n    \"8\": {\n        name: \"hy_desert\",\n        tag: \"Desert Storm\"\n    },\n    \"9\": {\n        name: \"hy_tiger\",\n        tag: \"Bengal Tiger\"\n    },\n    \"10\": {\n        name: \"hy_copperhead\",\n        tag: \"Copperhead\"\n    },\n    \"11\": {\n        name: \"hy_skulls\",\n        tag: \"Skulls\"\n    },\n    \"12\": {\n        name: \"hy_webs\",\n        tag: \"Crimson Web\"\n    },\n    \"13\": {\n        name: \"hy_splatter\",\n        tag: \"Blue Streak\"\n    },\n    \"14\": {\n        name: \"hy_ak47lam\",\n        tag: \"Red Laminate\"\n    },\n    \"15\": {\n        name: \"hy_gelpen\",\n        tag: \"Gunsmoke\"\n    },\n    \"16\": {\n        name: \"hy_v_tiger\",\n        tag: \"Jungle Tiger\"\n    },\n    \"17\": {\n        name: \"hy_ddpat_urb\",\n        tag: \"Urban DDPAT\"\n    },\n    \"20\": {\n        name: \"hy_zombie\",\n        tag: \"Virus\"\n    },\n    \"21\": {\n        name: \"hy_granite\",\n        tag: \"Granite Marbleized\"\n    },\n    \"22\": {\n        name: \"sp_spray\",\n        tag: \"Contrast Spray\"\n    },\n    \"25\": {\n        name: \"sp_leaves\",\n        tag: \"Forest Leaves\"\n    },\n    \"26\": {\n        name: \"sp_short_tape\",\n        tag: \"Lichen Dashed\"\n    },\n    \"27\": {\n        name: \"sp_tape\",\n        tag: \"Bone Mask\"\n    },\n    \"28\": {\n        name: \"an_navy\",\n        tag: \"Anodized Navy\"\n    },\n    \"30\": {\n        name: \"sp_snake\",\n        tag: \"Snake Camo\"\n    },\n    \"32\": {\n        name: \"an_silver\",\n        tag: \"Silver\"\n    },\n    \"33\": {\n        name: \"an_red\",\n        tag: \"Hot Rod\"\n    },\n    \"34\": {\n        name: \"am_urban\",\n        tag: \"Metallic DDPAT\"\n    },\n    \"36\": {\n        name: \"am_ossify\",\n        tag: \"Ossified\"\n    },\n    \"37\": {\n        name: \"aa_flames\",\n        tag: \"Blaze\"\n    },\n    \"38\": {\n        name: \"aa_fade\",\n        tag: \"Fade\"\n    },\n    \"39\": {\n        name: \"so_yellow\",\n        tag: \"Bulldozer\"\n    },\n    \"40\": {\n        name: \"so_night\",\n        tag: \"Night\"\n    },\n    \"41\": {\n        name: \"aq_copper\",\n        tag: \"Copper\"\n    },\n    \"42\": {\n        name: \"aq_blued\",\n        tag: \"Blue Steel\"\n    },\n    \"43\": {\n        name: \"aq_forced\",\n        tag: \"Stained\"\n    },\n    \"44\": {\n        name: \"aq_oiled\",\n        tag: \"Case Hardened\"\n    },\n    \"46\": {\n        name: \"so_pmc\",\n        tag: \"Contractor\"\n    },\n    \"47\": {\n        name: \"so_space_marine\",\n        tag: \"Colony\"\n    },\n    \"48\": {\n        name: \"am_dragon_glock\",\n        tag: \"Dragon Tattoo\"\n    },\n    \"51\": {\n        name: \"am_lightning_awp\",\n        tag: \"Lightning Strike\"\n    },\n    \"59\": {\n        name: \"am_zebra\",\n        tag: \"Slaughter\"\n    },\n    \"60\": {\n        name: \"am_zebra_dark\",\n        tag: \"Dark Water\"\n    },\n    \"61\": {\n        name: \"aa_vertigo\",\n        tag: \"Hypnotic\"\n    },\n    \"62\": {\n        name: \"cu_spring_nova\",\n        tag: \"Bloomstick\"\n    },\n    \"67\": {\n        name: \"am_slither_p90\",\n        tag: \"Cold Blooded\"\n    },\n    \"70\": {\n        name: \"am_carbon_fiber\",\n        tag: \"Carbon Fiber\"\n    },\n    \"71\": {\n        name: \"am_scorpion_p2000\",\n        tag: \"Scorpion\"\n    },\n    \"72\": {\n        name: \"sp_mesh_tan\",\n        tag: \"Safari Mesh\"\n    },\n    \"73\": {\n        name: \"hy_feathers_aug\",\n        tag: \"Wings\"\n    },\n    \"74\": {\n        name: \"hy_arctic_contrast\",\n        tag: \"Polar Camo\"\n    },\n    \"75\": {\n        name: \"hy_blizzard\",\n        tag: \"Blizzard Marbleized\"\n    },\n    \"76\": {\n        name: \"hy_forest_winter\",\n        tag: \"Winter Forest\"\n    },\n    \"77\": {\n        name: \"hy_forest_boreal\",\n        tag: \"Boreal Forest\"\n    },\n    \"78\": {\n        name: \"hy_forest_night\",\n        tag: \"Forest Night\"\n    },\n    \"83\": {\n        name: \"hy_ddpat_orange\",\n        tag: \"Orange DDPAT\"\n    },\n    \"84\": {\n        name: \"hy_ddpat_pink\",\n        tag: \"Pink DDPAT\"\n    },\n    \"90\": {\n        name: \"hy_mottled_sand\",\n        tag: \"Mudder\"\n    },\n    \"92\": {\n        name: \"hy_reef\",\n        tag: \"Cyanospatter\"\n    },\n    \"93\": {\n        name: \"so_caramel\",\n        tag: \"Caramel\"\n    },\n    \"95\": {\n        name: \"so_grassland\",\n        tag: \"Grassland\"\n    },\n    \"96\": {\n        name: \"so_moss\",\n        tag: \"Blue Spruce\"\n    },\n    \"98\": {\n        name: \"so_purple\",\n        tag: \"Ultraviolet\"\n    },\n    \"99\": {\n        name: \"so_sand\",\n        tag: \"Sand Dune\"\n    },\n    \"100\": {\n        name: \"so_stormfront\",\n        tag: \"Storm\"\n    },\n    \"101\": {\n        name: \"so_tornado\",\n        tag: \"Tornado\"\n    },\n    \"102\": {\n        name: \"so_whiteout\",\n        tag: \"Whiteout\"\n    },\n    \"104\": {\n        name: \"sp_leaves_grassland\",\n        tag: \"Grassland Leaves\"\n    },\n    \"107\": {\n        name: \"sp_mesh_arctic_contrast\",\n        tag: \"Polar Mesh\"\n    },\n    \"110\": {\n        name: \"sp_mesh_forest_fire\",\n        tag: \"Condemned\"\n    },\n    \"111\": {\n        name: \"sp_mesh_glacier\",\n        tag: \"Glacier Mesh\"\n    },\n    \"116\": {\n        name: \"sp_mesh_sand\",\n        tag: \"Sand Mesh\"\n    },\n    \"119\": {\n        name: \"sp_spray_desert_sage\",\n        tag: \"Sage Spray\"\n    },\n    \"122\": {\n        name: \"sp_spray_jungle\",\n        tag: \"Jungle Spray\"\n    },\n    \"124\": {\n        name: \"sp_spray_sand\",\n        tag: \"Sand Spray\"\n    },\n    \"125\": {\n        name: \"cu_xray_p250\",\n        tag: \"X-Ray\"\n    },\n    \"135\": {\n        name: \"sp_tape_dots_urban\",\n        tag: \"Urban Perforated\"\n    },\n    \"136\": {\n        name: \"sp_tape_dots_waves\",\n        tag: \"Waves Perforated\"\n    },\n    \"141\": {\n        name: \"sp_tape_orange\",\n        tag: \"Orange Peel\"\n    },\n    \"143\": {\n        name: \"sp_tape_urban\",\n        tag: \"Urban Masked\"\n    },\n    \"147\": {\n        name: \"sp_tape_short_jungle\",\n        tag: \"Jungle Dashed\"\n    },\n    \"148\": {\n        name: \"sp_tape_short_sand\",\n        tag: \"Sand Dashed\"\n    },\n    \"149\": {\n        name: \"sp_tape_short_urban\",\n        tag: \"Urban Dashed\"\n    },\n    \"151\": {\n        name: \"so_jungle\",\n        tag: \"Jungle\"\n    },\n    \"153\": {\n        name: \"so_tangerine\",\n        tag: \"Demolition\"\n    },\n    \"154\": {\n        name: \"cu_broken_path_famas\",\n        tag: \"Afterimage\"\n    },\n    \"155\": {\n        name: \"cu_bullet_rain_m4a1\",\n        tag: \"Bullet Rain\"\n    },\n    \"156\": {\n        name: \"cu_catskulls_p90\",\n        tag: \"Death by Kitty\"\n    },\n    \"157\": {\n        name: \"sp_palm\",\n        tag: \"Palm\"\n    },\n    \"158\": {\n        name: \"cu_walnut_nova\",\n        tag: \"Walnut\"\n    },\n    \"159\": {\n        name: \"aq_brass\",\n        tag: \"Brass\"\n    },\n    \"162\": {\n        name: \"sp_splash_p250\",\n        tag: \"Splash\"\n    },\n    \"164\": {\n        name: \"hy_hunter_modern\",\n        tag: \"Modern Hunter\"\n    },\n    \"165\": {\n        name: \"hy_hunter_blaze_pink\",\n        tag: \"Splash Jam\"\n    },\n    \"166\": {\n        name: \"hy_hunter_blaze_orange\",\n        tag: \"Blaze Orange\"\n    },\n    \"167\": {\n        name: \"sp_nukestripe_orange\",\n        tag: \"Radiation Hazard\"\n    },\n    \"168\": {\n        name: \"sp_nukestripe_green\",\n        tag: \"Nuclear Threat\"\n    },\n    \"169\": {\n        name: \"sp_nukestripe_maroon\",\n        tag: \"Fallout Warning\"\n    },\n    \"170\": {\n        name: \"sp_zebracam\",\n        tag: \"Predator\"\n    },\n    \"171\": {\n        name: \"sp_nukestripe_brown\",\n        tag: \"Irradiated Alert\"\n    },\n    \"172\": {\n        name: \"hy_ak47lam_bw\",\n        tag: \"Black Laminate\"\n    },\n    \"174\": {\n        name: \"hy_blam_simple\",\n        tag: \"BOOM\"\n    },\n    \"175\": {\n        name: \"sp_dapple\",\n        tag: \"Scorched\"\n    },\n    \"176\": {\n        name: \"sp_zebracam_bw\",\n        tag: \"Faded Zebra\"\n    },\n    \"177\": {\n        name: \"hy_icosahedron\",\n        tag: \"Memento\"\n    },\n    \"178\": {\n        name: \"hy_doomkitty\",\n        tag: \"Doomkitty\"\n    },\n    \"179\": {\n        name: \"sp_nukestripe_green_tec9\",\n        tag: \"Nuclear Threat\"\n    },\n    \"180\": {\n        name: \"cu_fireserpent_ak47_bravo\",\n        tag: \"Fire Serpent\"\n    },\n    \"181\": {\n        name: \"cu_favela_awp\",\n        tag: \"Corticera\"\n    },\n    \"182\": {\n        name: \"cu_dragon_p90_bravo\",\n        tag: \"Emerald Dragon\"\n    },\n    \"183\": {\n        name: \"hy_siege_bravo\",\n        tag: \"Overgrowth\"\n    },\n    \"184\": {\n        name: \"cu_favela_p2000\",\n        tag: \"Corticera\"\n    },\n    \"185\": {\n        name: \"am_scales_bravo\",\n        tag: \"Golden Koi\"\n    },\n    \"186\": {\n        name: \"sp_spray_waves_bravo\",\n        tag: \"Wave Spray\"\n    },\n    \"187\": {\n        name: \"sp_star_bravo\",\n        tag: \"Zirka\"\n    },\n    \"188\": {\n        name: \"aq_etched_mac10_bravo\",\n        tag: \"Graven\"\n    },\n    \"189\": {\n        name: \"hy_ocean_bravo\",\n        tag: \"Bright Water\"\n    },\n    \"190\": {\n        name: \"cu_season_elites_bravo\",\n        tag: \"Black Limba\"\n    },\n    \"191\": {\n        name: \"hy_seaside_bravo\",\n        tag: \"Tempest\"\n    },\n    \"192\": {\n        name: \"hy_crumple_bravo\",\n        tag: \"Shattered\"\n    },\n    \"193\": {\n        name: \"sp_skull_diagram_bravo\",\n        tag: \"Bone Pile\"\n    },\n    \"194\": {\n        name: \"sp_spitfire_famas_bravo\",\n        tag: \"Spitfire\"\n    },\n    \"195\": {\n        name: \"hy_bluepolygon_bravo\",\n        tag: \"Demeter\"\n    },\n    \"196\": {\n        name: \"an_emerald_bravo\",\n        tag: \"Emerald\"\n    },\n    \"197\": {\n        name: \"an_navy_bravo\",\n        tag: \"Anodized Navy\"\n    },\n    \"198\": {\n        name: \"sp_hazard_bravo\",\n        tag: \"Hazard\"\n    },\n    \"199\": {\n        name: \"sp_tape_dots_bravo\",\n        tag: \"Dry Season\"\n    },\n    \"200\": {\n        name: \"hy_mayan_dreams_bravo\",\n        tag: \"Mayan Dreams\"\n    },\n    \"201\": {\n        name: \"sp_palm_bravo\",\n        tag: \"Palm\"\n    },\n    \"202\": {\n        name: \"hy_ddpat_jungle_bravo\",\n        tag: \"Jungle DDPAT\"\n    },\n    \"203\": {\n        name: \"aq_steel_bravo\",\n        tag: \"Rust Coat\"\n    },\n    \"204\": {\n        name: \"hy_ali_tile_bravo\",\n        tag: \"Mosaico\"\n    },\n    \"205\": {\n        name: \"so_jungle_bravo\",\n        tag: \"Jungle\"\n    },\n    \"206\": {\n        name: \"so_tornado_bravo\",\n        tag: \"Tornado\"\n    },\n    \"207\": {\n        name: \"hy_crumple_dark_bravo\",\n        tag: \"Facets\"\n    },\n    \"208\": {\n        name: \"so_sand_bravo\",\n        tag: \"Sand Dune\"\n    },\n    \"209\": {\n        name: \"so_olive_bravo\",\n        tag: \"Groundwater\"\n    },\n    \"210\": {\n        name: \"an_gunmetal_bravo\",\n        tag: \"Anodized Gunmetal\"\n    },\n    \"211\": {\n        name: \"am_ossify_blue_p2000_bravo\",\n        tag: \"Ocean Foam\"\n    },\n    \"212\": {\n        name: \"am_crumple_bravo\",\n        tag: \"Graphite\"\n    },\n    \"213\": {\n        name: \"am_ossify_blue\",\n        tag: \"Ocean Foam\"\n    },\n    \"214\": {\n        name: \"am_crumple\",\n        tag: \"Graphite\"\n    },\n    \"215\": {\n        name: \"cu_xray_m4\",\n        tag: \"X-Ray\"\n    },\n    \"216\": {\n        name: \"an_titanium30v\",\n        tag: \"Blue Titanium\"\n    },\n    \"217\": {\n        name: \"hy_redtiger\",\n        tag: \"Blood Tiger\"\n    },\n    \"218\": {\n        name: \"hy_bluehex\",\n        tag: \"Hexane\"\n    },\n    \"219\": {\n        name: \"hy_redhex\",\n        tag: \"Hive\"\n    },\n    \"220\": {\n        name: \"am_ossify_red\",\n        tag: \"Hemoglobin\"\n    },\n    \"221\": {\n        name: \"am_electric_red\",\n        tag: \"Serum\"\n    },\n    \"222\": {\n        name: \"cu_shark\",\n        tag: \"Blood in the Water\"\n    },\n    \"223\": {\n        name: \"hy_flowers\",\n        tag: \"Nightshade\"\n    },\n    \"224\": {\n        name: \"hy_water_crest\",\n        tag: \"Water Sigil\"\n    },\n    \"225\": {\n        name: \"sp_camo_wood_blue\",\n        tag: \"Ghost Camo\"\n    },\n    \"226\": {\n        name: \"hy_ak47lam_blue\",\n        tag: \"Blue Laminate\"\n    },\n    \"227\": {\n        name: \"hy_hive\",\n        tag: \"Electric Hive\"\n    },\n    \"228\": {\n        name: \"hy_modspots\",\n        tag: \"Blind Spot\"\n    },\n    \"229\": {\n        name: \"sp_zebracam_blue\",\n        tag: \"Azure Zebra\"\n    },\n    \"230\": {\n        name: \"am_ddpatdense_silver\",\n        tag: \"Steel Disruption\"\n    },\n    \"231\": {\n        name: \"am_ddpatdense_peacock\",\n        tag: \"Cobalt Disruption\"\n    },\n    \"232\": {\n        name: \"hy_webs_darker\",\n        tag: \"Crimson Web\"\n    },\n    \"233\": {\n        name: \"sp_palm_shadow\",\n        tag: \"Tropical Storm\"\n    },\n    \"234\": {\n        name: \"sp_twigs\",\n        tag: \"Ash Wood\"\n    },\n    \"235\": {\n        name: \"hy_varicamo\",\n        tag: \"VariCamo\"\n    },\n    \"236\": {\n        name: \"hy_varicamo_night\",\n        tag: \"Night Ops\"\n    },\n    \"237\": {\n        name: \"hy_varicamo_urban\",\n        tag: \"Urban Rubble\"\n    },\n    \"238\": {\n        name: \"hy_varicamo_blue\",\n        tag: \"VariCamo Blue\"\n    },\n    \"240\": {\n        name: \"hy_varicamo_desert\",\n        tag: \"CaliCamo\"\n    },\n    \"241\": {\n        name: \"sp_mesh_slashes\",\n        tag: \"Hunting Blind\"\n    },\n    \"242\": {\n        name: \"sp_mesh_army\",\n        tag: \"Army Mesh\"\n    },\n    \"243\": {\n        name: \"sp_mesh_python\",\n        tag: \"Gator Mesh\"\n    },\n    \"244\": {\n        name: \"sp_mesh_hot_and_cold\",\n        tag: \"Teardown\"\n    },\n    \"245\": {\n        name: \"sp_spray_army\",\n        tag: \"Army Recon\"\n    },\n    \"246\": {\n        name: \"aa_fade_metallic\",\n        tag: \"Amber Fade\"\n    },\n    \"247\": {\n        name: \"aq_damascus_sg553\",\n        tag: \"Damascus Steel\"\n    },\n    \"248\": {\n        name: \"am_crystallized\",\n        tag: \"Red Quartz\"\n    },\n    \"249\": {\n        name: \"am_crystallized_blue\",\n        tag: \"Cobalt Quartz\"\n    },\n    \"250\": {\n        name: \"hy_varicamo_red\",\n        tag: \"Full Stop\"\n    },\n    \"251\": {\n        name: \"hy_snakeskin\",\n        tag: \"Pit Viper\"\n    },\n    \"252\": {\n        name: \"am_crystallized_silver\",\n        tag: \"Silver Quartz\"\n    },\n    \"253\": {\n        name: \"aa_fade_grassland\",\n        tag: \"Acid Fade\"\n    },\n    \"254\": {\n        name: \"so_orange_accents\",\n        tag: \"Nitro\"\n    },\n    \"255\": {\n        name: \"cu_m4_asimov\",\n        tag: \"Asiimov\"\n    },\n    \"256\": {\n        name: \"cu_sawedoff_octopump\",\n        tag: \"The Kraken\"\n    },\n    \"257\": {\n        name: \"cu_m4a1-s_elegant\",\n        tag: \"Guardian\"\n    },\n    \"258\": {\n        name: \"cu_p250_refined\",\n        tag: \"Mehndi\"\n    },\n    \"259\": {\n        name: \"cu_awp_cobra\",\n        tag: \"Redline\"\n    },\n    \"260\": {\n        name: \"cu_famas_pulse\",\n        tag: \"Pulse\"\n    },\n    \"261\": {\n        name: \"hy_marina_sunrise\",\n        tag: \"Marina\"\n    },\n    \"262\": {\n        name: \"am_thorny_rose_mp9\",\n        tag: \"Rose Iron\"\n    },\n    \"263\": {\n        name: \"cu_skull_nova\",\n        tag: \"Rising Skull\"\n    },\n    \"264\": {\n        name: \"cu_sandstorm\",\n        tag: \"Sandstorm\"\n    },\n    \"265\": {\n        name: \"hy_kami\",\n        tag: \"Kami\"\n    },\n    \"266\": {\n        name: \"aq_obsidian\",\n        tag: \"Magma\"\n    },\n    \"267\": {\n        name: \"am_turqoise_halftone\",\n        tag: \"Cobalt Halftone\"\n    },\n    \"268\": {\n        name: \"am_diamond_plate\",\n        tag: \"Tread Plate\"\n    },\n    \"269\": {\n        name: \"am_fuschia\",\n        tag: \"The Fuschia Is Now\"\n    },\n    \"270\": {\n        name: \"aq_etched_cz75\",\n        tag: \"Victoria\"\n    },\n    \"271\": {\n        name: \"am_p250_beaded_paint\",\n        tag: \"Undertow\"\n    },\n    \"272\": {\n        name: \"am_fluted_tec9\",\n        tag: \"Titanium Bit\"\n    },\n    \"273\": {\n        name: \"aq_engraved_deagle\",\n        tag: \"Heirloom\"\n    },\n    \"274\": {\n        name: \"am_copper_flecks\",\n        tag: \"Copper Galaxy\"\n    },\n    \"275\": {\n        name: \"hy_poly_camo\",\n        tag: \"Red FragCam\"\n    },\n    \"276\": {\n        name: \"so_panther\",\n        tag: \"Panther\"\n    },\n    \"277\": {\n        name: \"aq_usp_stainless\",\n        tag: \"Stainless\"\n    },\n    \"278\": {\n        name: \"hy_craquelure\",\n        tag: \"Blue Fissure\"\n    },\n    \"279\": {\n        name: \"cu_awp_asimov\",\n        tag: \"Asiimov\"\n    },\n    \"280\": {\n        name: \"cu_aug_chameleonaire\",\n        tag: \"Chameleon\"\n    },\n    \"281\": {\n        name: \"cu_ump_corporal\",\n        tag: \"Corporal\"\n    },\n    \"282\": {\n        name: \"cu_ak47_cobra\",\n        tag: \"Redline\"\n    },\n    \"283\": {\n        name: \"cu_p90_trigon\",\n        tag: \"Trigon\"\n    },\n    \"284\": {\n        name: \"cu_mac10_redhot\",\n        tag: \"Heat\"\n    },\n    \"285\": {\n        name: \"sp_negev_turq_terrain\",\n        tag: \"Terrain\"\n    },\n    \"286\": {\n        name: \"cu_nova_antique\",\n        tag: \"Antique\"\n    },\n    \"287\": {\n        name: \"cu_sg553_pulse\",\n        tag: \"Pulse\"\n    },\n    \"288\": {\n        name: \"an_famas_sgt\",\n        tag: \"Sergeant\"\n    },\n    \"289\": {\n        name: \"cu_tec9_sandstorm\",\n        tag: \"Sandstorm\"\n    },\n    \"290\": {\n        name: \"cu_usp_elegant\",\n        tag: \"Guardian\"\n    },\n    \"291\": {\n        name: \"cu_mag7_heaven\",\n        tag: \"Heaven Guard\"\n    },\n    \"293\": {\n        name: \"hy_nerodia\",\n        tag: \"Death Rattle\"\n    },\n    \"294\": {\n        name: \"so_green\",\n        tag: \"Green Apple\"\n    },\n    \"295\": {\n        name: \"cu_money\",\n        tag: \"Franklin\"\n    },\n    \"296\": {\n        name: \"am_crystallized_dark\",\n        tag: \"Meteorite\"\n    },\n    \"297\": {\n        name: \"so_orca\",\n        tag: \"Tuxedo\"\n    },\n    \"298\": {\n        name: \"am_army_shine\",\n        tag: \"Army Sheen\"\n    },\n    \"299\": {\n        name: \"am_oval_hex\",\n        tag: \"Caged Steel\"\n    },\n    \"300\": {\n        name: \"cu_pinstripe_ak47\",\n        tag: \"Emerald Pinstripe\"\n    },\n    \"301\": {\n        name: \"am_m4a1-s_alloy_orange\",\n        tag: \"Atomic Alloy\"\n    },\n    \"302\": {\n        name: \"cu_ak47_rubber\",\n        tag: \"Vulcan\"\n    },\n    \"303\": {\n        name: \"cu_tec9_asiimov\",\n        tag: \"Isaac\"\n    },\n    \"304\": {\n        name: \"cu_ssg08_immortal\",\n        tag: \"Slashed\"\n    },\n    \"305\": {\n        name: \"cu_aug_progressiv\",\n        tag: \"Torque\"\n    },\n    \"306\": {\n        name: \"cu_bizon_antique\",\n        tag: \"Antique\"\n    },\n    \"307\": {\n        name: \"cu_retribution\",\n        tag: \"Retribution\"\n    },\n    \"308\": {\n        name: \"hy_galil_kami\",\n        tag: \"Kami\"\n    },\n    \"309\": {\n        name: \"cu_m4a1_howling\",\n        tag: \"Howl\"\n    },\n    \"310\": {\n        name: \"cu_mac10_decay\",\n        tag: \"Curse\"\n    },\n    \"311\": {\n        name: \"cu_p90_scorpius\",\n        tag: \"Desert Warfare\"\n    },\n    \"312\": {\n        name: \"cu_scar_cyrex\",\n        tag: \"Cyrex\"\n    },\n    \"313\": {\n        name: \"cu_usp_spitfire\",\n        tag: \"Orion\"\n    },\n    \"314\": {\n        name: \"cu_xm1014_heaven_guard\",\n        tag: \"Heaven Guard\"\n    },\n    \"315\": {\n        name: \"am_nitrogen\",\n        tag: \"Poison Dart\"\n    },\n    \"316\": {\n        name: \"cu_panther_ak47\",\n        tag: \"Jaguar\"\n    },\n    \"317\": {\n        name: \"cu_bratatat_negev\",\n        tag: \"Bratatat\"\n    },\n    \"318\": {\n        name: \"cu_usp_sandpapered\",\n        tag: \"Road Rash\"\n    },\n    \"319\": {\n        name: \"hy_ssg08_marker\",\n        tag: \"Detour\"\n    },\n    \"320\": {\n        name: \"hy_snakeskin_red\",\n        tag: \"Red Python\"\n    },\n    \"321\": {\n        name: \"cu_m4a1-s_silence\",\n        tag: \"Master Piece\"\n    },\n    \"322\": {\n        name: \"so_orange_accents2\",\n        tag: \"Nitro\"\n    },\n    \"323\": {\n        name: \"aq_steel\",\n        tag: \"Rust Coat\"\n    },\n    \"325\": {\n        name: \"am_royal\",\n        tag: \"Chalice\"\n    },\n    \"326\": {\n        name: \"am_metals\",\n        tag: \"Knight\"\n    },\n    \"327\": {\n        name: \"am_chainmail\",\n        tag: \"Chainmail\"\n    },\n    \"328\": {\n        name: \"aq_handcannon\",\n        tag: \"Hand Cannon\"\n    },\n    \"329\": {\n        name: \"am_metal_inlay\",\n        tag: \"Dark Age\"\n    },\n    \"330\": {\n        name: \"hy_vines\",\n        tag: \"Briar\"\n    },\n    \"332\": {\n        name: \"hy_indigo_usp\",\n        tag: \"Royal Blue\"\n    },\n    \"333\": {\n        name: \"so_indigo_and_grey\",\n        tag: \"Indigo\"\n    },\n    \"334\": {\n        name: \"am_gyrate\",\n        tag: \"Twist\"\n    },\n    \"335\": {\n        name: \"an_royalbleed\",\n        tag: \"Module\"\n    },\n    \"336\": {\n        name: \"cu_titanstorm\",\n        tag: \"Desert-Strike\"\n    },\n    \"337\": {\n        name: \"cu_korupt\",\n        tag: \"Tatter\"\n    },\n    \"338\": {\n        name: \"cu_p2000_pulse\",\n        tag: \"Pulse\"\n    },\n    \"339\": {\n        name: \"cu_kaiman\",\n        tag: \"Caiman\"\n    },\n    \"340\": {\n        name: \"cu_well_traveled_ak47\",\n        tag: \"Jet Set\"\n    },\n    \"341\": {\n        name: \"cu_green_leather_ak47\",\n        tag: \"First Class\"\n    },\n    \"342\": {\n        name: \"cu_brown_leather_p90\",\n        tag: \"Leather\"\n    },\n    \"343\": {\n        name: \"cu_luggage_mac10\",\n        tag: \"Commuter\"\n    },\n    \"344\": {\n        name: \"cu_medieval_dragon_awp\",\n        tag: \"Dragon Lore\"\n    },\n    \"345\": {\n        name: \"cu_green_leather_sawedoff\",\n        tag: \"First Class\"\n    },\n    \"346\": {\n        name: \"cu_luggage_p2000\",\n        tag: \"Coach Class\"\n    },\n    \"347\": {\n        name: \"aq_pilot_deagle\",\n        tag: \"Pilot\"\n    },\n    \"348\": {\n        name: \"cu_leather_xm1014\",\n        tag: \"Red Leather\"\n    },\n    \"349\": {\n        name: \"cu_bizon-osiris\",\n        tag: \"Osiris\"\n    },\n    \"350\": {\n        name: \"cu_c75a-tiger\",\n        tag: \"Tigris\"\n    },\n    \"351\": {\n        name: \"cu_deagle_aureus\",\n        tag: \"Conspiracy\"\n    },\n    \"352\": {\n        name: \"aq_57_feathers\",\n        tag: \"Fowl Play\"\n    },\n    \"353\": {\n        name: \"cu_glock-liquescent\",\n        tag: \"Water Elemental\"\n    },\n    \"354\": {\n        name: \"cu_mp7-commander\",\n        tag: \"Urban Hazard\"\n    },\n    \"355\": {\n        name: \"cu_negev_titanstorm\",\n        tag: \"Desert-Strike\"\n    },\n    \"356\": {\n        name: \"cu_nova_koi\",\n        tag: \"Koi\"\n    },\n    \"357\": {\n        name: \"cu_p2000_ivory\",\n        tag: \"Ivory\"\n    },\n    \"358\": {\n        name: \"cu_bittersweet\",\n        tag: \"Supernova\"\n    },\n    \"359\": {\n        name: \"cu_p90-asiimov\",\n        tag: \"Asiimov\"\n    },\n    \"360\": {\n        name: \"cu_m4a1s_cyrex\",\n        tag: \"Cyrex\"\n    },\n    \"361\": {\n        name: \"aq_leviathan\",\n        tag: \"Abyss\"\n    },\n    \"362\": {\n        name: \"hy_lines_orange\",\n        tag: \"Labyrinth\"\n    },\n    \"363\": {\n        name: \"cu_luggage_sg553\",\n        tag: \"Traveler\"\n    },\n    \"364\": {\n        name: \"cu_luggage_usp-s\",\n        tag: \"Business Class\"\n    },\n    \"365\": {\n        name: \"hy_plaid1\",\n        tag: \"Olive Plaid\"\n    },\n    \"366\": {\n        name: \"hy_plaid2\",\n        tag: \"Green Plaid\"\n    },\n    \"367\": {\n        name: \"am_nuclear_pattern1_glock\",\n        tag: \"Reactor\"\n    },\n    \"368\": {\n        name: \"hy_nuclear_pattern2_mp9\",\n        tag: \"Setting Sun\"\n    },\n    \"369\": {\n        name: \"sp_nuclear_pattern3_negev\",\n        tag: \"Nuclear Waste\"\n    },\n    \"370\": {\n        name: \"am_nuclear_skulls1_xm1014\",\n        tag: \"Bone Machine\"\n    },\n    \"371\": {\n        name: \"am_nuclear_skulls2_famas\",\n        tag: \"Styx\"\n    },\n    \"372\": {\n        name: \"am_nuclear_skulls3_mac10\",\n        tag: \"Nuclear Garden\"\n    },\n    \"373\": {\n        name: \"hy_nuclear_skulls4_p250\",\n        tag: \"Contamination\"\n    },\n    \"374\": {\n        name: \"hy_nuclear_skulls5_tec9\",\n        tag: \"Toxic\"\n    },\n    \"375\": {\n        name: \"sp_nukestripe_orange_aug\",\n        tag: \"Radiation Hazard\"\n    },\n    \"376\": {\n        name: \"so_grey_nuclear_green_bizon\",\n        tag: \"Chemical Green\"\n    },\n    \"377\": {\n        name: \"so_grey_nuclear_orange_five_seven\",\n        tag: \"Hot Shot\"\n    },\n    \"378\": {\n        name: \"sp_nukestripe_maroon_sg553\",\n        tag: \"Fallout Warning\"\n    },\n    \"379\": {\n        name: \"cu_cerbrus_galil\",\n        tag: \"Cerberus\"\n    },\n    \"380\": {\n        name: \"cu_tribute_ak47\",\n        tag: \"Wasteland Rebel\"\n    },\n    \"381\": {\n        name: \"aq_glock_coiled\",\n        tag: \"Grinder\"\n    },\n    \"382\": {\n        name: \"am_g3sg1_murky\",\n        tag: \"Murky\"\n    },\n    \"383\": {\n        name: \"aq_m4a1s_basilisk\",\n        tag: \"Basilisk\"\n    },\n    \"384\": {\n        name: \"cu_m4a4_griffin\",\n        tag: \"Griffin\"\n    },\n    \"385\": {\n        name: \"sp_mag7_firebitten\",\n        tag: \"Firestarter\"\n    },\n    \"386\": {\n        name: \"cu_mp9_chevron\",\n        tag: \"Dart\"\n    },\n    \"387\": {\n        name: \"cu_fiveseven_urban_hazard\",\n        tag: \"Urban Hazard\"\n    },\n    \"388\": {\n        name: \"aq_p250_cartel\",\n        tag: \"Cartel\"\n    },\n    \"389\": {\n        name: \"cu_p2000_fire_elemental\",\n        tag: \"Fire Elemental\"\n    },\n    \"390\": {\n        name: \"aq_sawedoff_blackgold\",\n        tag: \"Highwayman\"\n    },\n    \"391\": {\n        name: \"cu_scar20_intervention\",\n        tag: \"Cardiac\"\n    },\n    \"392\": {\n        name: \"sp_ump45_d-visions\",\n        tag: \"Delusion\"\n    },\n    \"393\": {\n        name: \"cu_xm1014_caritas\",\n        tag: \"Tranquility\"\n    },\n    \"394\": {\n        name: \"aq_ak47_cartel\",\n        tag: \"Cartel\"\n    },\n    \"395\": {\n        name: \"am_awp_glory\",\n        tag: \"Man-o'-war\"\n    },\n    \"396\": {\n        name: \"cu_elites_urbanstorm\",\n        tag: \"Urban Shock\"\n    },\n    \"397\": {\n        name: \"aq_deagle_naga\",\n        tag: \"Naga\"\n    },\n    \"398\": {\n        name: \"cu_galil_abrasion\",\n        tag: \"Chatterbox\"\n    },\n    \"399\": {\n        name: \"cu_glock_deathtoll\",\n        tag: \"Catacombs\"\n    },\n    \"400\": {\n        name: \"cu_m4a4_ancestral\",\n        tag: \"龍王 (Dragon King)\"\n    },\n    \"401\": {\n        name: \"cu_m249_sektor\",\n        tag: \"System Lock\"\n    },\n    \"402\": {\n        name: \"am_mac10_malachite\",\n        tag: \"Malachite\"\n    },\n    \"403\": {\n        name: \"cu_mp9_deadly_poison\",\n        tag: \"Deadly Poison\"\n    },\n    \"404\": {\n        name: \"cu_p250_mandala\",\n        tag: \"Muertos\"\n    },\n    \"405\": {\n        name: \"cu_sawedoff_deva\",\n        tag: \"Serenity\"\n    },\n    \"406\": {\n        name: \"aq_scar20_leak\",\n        tag: \"Grotto\"\n    },\n    \"407\": {\n        name: \"aq_xm1014_sigla\",\n        tag: \"Quicksilver\"\n    },\n    \"409\": {\n        name: \"an_tiger_orange\",\n        tag: \"Tiger Tooth\"\n    },\n    \"410\": {\n        name: \"aq_damascus\",\n        tag: \"Damascus Steel\"\n    },\n    \"411\": {\n        name: \"aq_damascus_90\",\n        tag: \"Damascus Steel\"\n    },\n    \"413\": {\n        name: \"am_marble_fade\",\n        tag: \"Marble Fade\"\n    },\n    \"414\": {\n        name: \"aq_steel_knife\",\n        tag: \"Rust Coat\"\n    },\n    \"415\": {\n        name: \"am_ruby_marbleized\",\n        tag: \"Doppler\"\n    },\n    \"416\": {\n        name: \"am_sapphire_marbleized\",\n        tag: \"Doppler\"\n    },\n    \"417\": {\n        name: \"am_blackpearl_marbleized\",\n        tag: \"Doppler\"\n    },\n    \"418\": {\n        name: \"am_doppler_phase1\",\n        tag: \"Doppler\"\n    },\n    \"419\": {\n        name: \"am_doppler_phase2\",\n        tag: \"Doppler\"\n    },\n    \"420\": {\n        name: \"am_doppler_phase3\",\n        tag: \"Doppler\"\n    },\n    \"421\": {\n        name: \"am_doppler_phase4\",\n        tag: \"Doppler\"\n    },\n    \"422\": {\n        name: \"cu_ak47_mastery\",\n        tag: \"Elite Build\"\n    },\n    \"423\": {\n        name: \"aq_mp7_ultramodern\",\n        tag: \"Armor Core\"\n    },\n    \"424\": {\n        name: \"aq_awp_twine\",\n        tag: \"Worm God\"\n    },\n    \"425\": {\n        name: \"am_bronze_sparkle\",\n        tag: \"Bronze Deco\"\n    },\n    \"426\": {\n        name: \"aq_p250_contour\",\n        tag: \"Valence\"\n    },\n    \"427\": {\n        name: \"cu_fiveseven_banana\",\n        tag: \"Monkey Business\"\n    },\n    \"428\": {\n        name: \"cu_galil_eco\",\n        tag: \"Eco\"\n    },\n    \"429\": {\n        name: \"aq_famas_jinn\",\n        tag: \"Djinn\"\n    },\n    \"430\": {\n        name: \"cu_m4a1_hyper_beast\",\n        tag: \"Hyper Beast\"\n    },\n    \"431\": {\n        name: \"cu_mag7_redhot\",\n        tag: \"Heat\"\n    },\n    \"432\": {\n        name: \"am_negev_glory\",\n        tag: \"Man-o'-war\"\n    },\n    \"433\": {\n        name: \"cu_mac10_neonrider\",\n        tag: \"Neon Rider\"\n    },\n    \"434\": {\n        name: \"cu_sawedoff_origami\",\n        tag: \"Origami\"\n    },\n    \"435\": {\n        name: \"cu_cz75_precision\",\n        tag: \"Pole Position\"\n    },\n    \"436\": {\n        name: \"am_ump_racer\",\n        tag: \"Grand Prix\"\n    },\n    \"437\": {\n        name: \"am_aqua_flecks\",\n        tag: \"Twilight Galaxy\"\n    },\n    \"438\": {\n        name: \"cu_chronos_g3sg1\",\n        tag: \"Chronos\"\n    },\n    \"439\": {\n        name: \"hy_hades\",\n        tag: \"Hades\"\n    },\n    \"440\": {\n        name: \"hy_icarus\",\n        tag: \"Icarus Fell\"\n    },\n    \"441\": {\n        name: \"cu_labyrinth\",\n        tag: \"Minotaur's Labyrinth\"\n    },\n    \"442\": {\n        name: \"sp_labyrinth\",\n        tag: \"Asterion\"\n    },\n    \"443\": {\n        name: \"sp_labyrinth2\",\n        tag: \"Pathfinder\"\n    },\n    \"444\": {\n        name: \"sp_labyrinth3\",\n        tag: \"Daedalus\"\n    },\n    \"445\": {\n        name: \"an_red_m4a1s\",\n        tag: \"Hot Rod\"\n    },\n    \"446\": {\n        name: \"cu_medusa_awp\",\n        tag: \"Medusa\"\n    },\n    \"447\": {\n        name: \"gs_mother_of_pearl_elite\",\n        tag: \"Duelist\"\n    },\n    \"448\": {\n        name: \"aa_pandora\",\n        tag: \"Pandora's Box\"\n    },\n    \"449\": {\n        name: \"cu_poseidon\",\n        tag: \"Poseidon\"\n    },\n    \"450\": {\n        name: \"hy_zodiac1\",\n        tag: \"Moon in Libra\"\n    },\n    \"451\": {\n        name: \"hy_zodiac2\",\n        tag: \"Sun in Leo\"\n    },\n    \"452\": {\n        name: \"hy_zodiac3\",\n        tag: \"Shipping Forecast\"\n    },\n    \"453\": {\n        name: \"an_emerald\",\n        tag: \"Emerald\"\n    },\n    \"454\": {\n        name: \"so_khaki_green\",\n        tag: \"Para Green\"\n    },\n    \"455\": {\n        name: \"cu_anime_aug\",\n        tag: \"Akihabara Accept\"\n    },\n    \"456\": {\n        name: \"am_bamboo_jungle\",\n        tag: \"Hydroponic\"\n    },\n    \"457\": {\n        name: \"hy_bamboo_jungle_ink\",\n        tag: \"Bamboo Print\"\n    },\n    \"458\": {\n        name: \"hy_bamboo_jungle_black\",\n        tag: \"Bamboo Shadow\"\n    },\n    \"459\": {\n        name: \"hy_bamboo_jungle\",\n        tag: \"Bamboo Forest\"\n    },\n    \"460\": {\n        name: \"am_geometric_steps\",\n        tag: \"Aqua Terrace\"\n    },\n    \"462\": {\n        name: \"hy_geometric_steps_green\",\n        tag: \"Counter Terrace\"\n    },\n    \"463\": {\n        name: \"hy_geometric_steps_yellow\",\n        tag: \"Terrace\"\n    },\n    \"464\": {\n        name: \"hy_kimono_diamonds\",\n        tag: \"Neon Kimono\"\n    },\n    \"465\": {\n        name: \"hy_kimono_diamonds_orange\",\n        tag: \"Orange Kimono\"\n    },\n    \"466\": {\n        name: \"hy_kimono_diamonds_red\",\n        tag: \"Crimson Kimono\"\n    },\n    \"467\": {\n        name: \"sp_kimono_diamonds\",\n        tag: \"Mint Kimono\"\n    },\n    \"468\": {\n        name: \"am_seastorm\",\n        tag: \"Midnight Storm\"\n    },\n    \"469\": {\n        name: \"am_seastorm_blood\",\n        tag: \"Sunset Storm 壱\"\n    },\n    \"470\": {\n        name: \"am_seastorm_shojo\",\n        tag: \"Sunset Storm 弐\"\n    },\n    \"471\": {\n        name: \"am_kimono_sunrise\",\n        tag: \"Daybreak\"\n    },\n    \"472\": {\n        name: \"so_keycolors\",\n        tag: \"Impact Drill\"\n    },\n    \"473\": {\n        name: \"so_aqua\",\n        tag: \"Seabird\"\n    },\n    \"474\": {\n        name: \"cu_ak47_courage_alt\",\n        tag: \"Aquamarine Revenge\"\n    },\n    \"475\": {\n        name: \"cu_awp_hyper_beast\",\n        tag: \"Hyper Beast\"\n    },\n    \"476\": {\n        name: \"cu_cz75a_chastizer\",\n        tag: \"Yellow Jacket\"\n    },\n    \"477\": {\n        name: \"am_famas_dots\",\n        tag: \"Neural Net\"\n    },\n    \"478\": {\n        name: \"cu_galilar_particles\",\n        tag: \"Rocket Pop\"\n    },\n    \"479\": {\n        name: \"aq_glock18_flames_blue\",\n        tag: \"Bunsen Burner\"\n    },\n    \"480\": {\n        name: \"cu_m4a4_evil_daimyo\",\n        tag: \"Evil Daimyo\"\n    },\n    \"481\": {\n        name: \"cu_mp7_nemsis\",\n        tag: \"Nemesis\"\n    },\n    \"482\": {\n        name: \"am_mp9_nitrogen\",\n        tag: \"Ruby Poison Dart\"\n    },\n    \"483\": {\n        name: \"cu_negev_annihilator\",\n        tag: \"Loudmouth\"\n    },\n    \"484\": {\n        name: \"cu_nova_ranger\",\n        tag: \"Ranger\"\n    },\n    \"485\": {\n        name: \"aq_p2000_boom\",\n        tag: \"Handgun\"\n    },\n    \"486\": {\n        name: \"cu_p90_mastery\",\n        tag: \"Elite Build\"\n    },\n    \"487\": {\n        name: \"cu_sg553_cyrex\",\n        tag: \"Cyrex\"\n    },\n    \"488\": {\n        name: \"cu_ump45_uproar\",\n        tag: \"Riot\"\n    },\n    \"489\": {\n        name: \"cu_usp_progressiv\",\n        tag: \"Torque\"\n    },\n    \"490\": {\n        name: \"cu_ak47_winter_sport\",\n        tag: \"Frontside Misty\"\n    },\n    \"491\": {\n        name: \"cu_dualberretta_dragons\",\n        tag: \"Dualing Dragons\"\n    },\n    \"492\": {\n        name: \"cu_famas_lenta\",\n        tag: \"Survivor Z\"\n    },\n    \"493\": {\n        name: \"gs_g3sg1_flux_purple\",\n        tag: \"Flux\"\n    },\n    \"494\": {\n        name: \"gs_galil_nightwing\",\n        tag: \"Stone Cold\"\n    },\n    \"495\": {\n        name: \"gs_glock18_wrathys\",\n        tag: \"Wraiths\"\n    },\n    \"496\": {\n        name: \"gs_m249_nebula_crusader\",\n        tag: \"Nebula Crusader\"\n    },\n    \"497\": {\n        name: \"gs_m4a1s_snakebite_gold\",\n        tag: \"Golden Coil\"\n    },\n    \"498\": {\n        name: \"cu_mac10_alekhya_duo\",\n        tag: \"Rangeen\"\n    },\n    \"499\": {\n        name: \"cu_mag7_myrcene\",\n        tag: \"Cobalt Core\"\n    },\n    \"500\": {\n        name: \"cu_mp7_classified\",\n        tag: \"Special Delivery\"\n    },\n    \"501\": {\n        name: \"hy_p250_crackshot\",\n        tag: \"Wingshot\"\n    },\n    \"502\": {\n        name: \"gs_scar20_peacemaker03\",\n        tag: \"Green Marine\"\n    },\n    \"503\": {\n        name: \"cu_ssg08_technicality\",\n        tag: \"Big Iron\"\n    },\n    \"504\": {\n        name: \"cu_usp_kill_confirmed\",\n        tag: \"Kill Confirmed\"\n    },\n    \"505\": {\n        name: \"aq_xm1014_scumbria\",\n        tag: \"Scumbria\"\n    },\n    \"506\": {\n        name: \"cu_ak47_point_disarray\",\n        tag: \"Point Disarray\"\n    },\n    \"507\": {\n        name: \"am_aug_jumble\",\n        tag: \"Ricochet\"\n    },\n    \"508\": {\n        name: \"cu_bizon_noxious\",\n        tag: \"Fuel Rod\"\n    },\n    \"509\": {\n        name: \"aq_deagle_corinthian\",\n        tag: \"Corinthian\"\n    },\n    \"510\": {\n        name: \"cu_fiveseven_retrobution\",\n        tag: \"Retrobution\"\n    },\n    \"511\": {\n        name: \"cu_g3sg1_executioner\",\n        tag: \"The Executioner\"\n    },\n    \"512\": {\n        name: \"gs_m4a4_royal_squire\",\n        tag: \"Royal Paladin\"\n    },\n    \"514\": {\n        name: \"cu_negev_impact\",\n        tag: \"Power Loader\"\n    },\n    \"515\": {\n        name: \"am_p2000_imperial_red\",\n        tag: \"Imperial\"\n    },\n    \"516\": {\n        name: \"cu_p90_shapewood\",\n        tag: \"Shapewood\"\n    },\n    \"517\": {\n        name: \"gs_sawedoff_necromancer\",\n        tag: \"Yorick\"\n    },\n    \"518\": {\n        name: \"hy_scar20_jungler\",\n        tag: \"Outbreak\"\n    },\n    \"519\": {\n        name: \"gs_sg553_tiger_moth\",\n        tag: \"Tiger Moth\"\n    },\n    \"520\": {\n        name: \"cu_tec9_avalanche\",\n        tag: \"Avalanche\"\n    },\n    \"521\": {\n        name: \"aq_xm1014_hot_rod\",\n        tag: \"Teclu Burner\"\n    },\n    \"522\": {\n        name: \"aa_fade_revolver\",\n        tag: \"Fade\"\n    },\n    \"523\": {\n        name: \"aa_fade_metallic_revolver\",\n        tag: \"Amber Fade\"\n    },\n    \"524\": {\n        name: \"gs_ak47_supercharged\",\n        tag: \"Fuel Injector\"\n    },\n    \"525\": {\n        name: \"cu_awp_mastery\",\n        tag: \"Elite Build\"\n    },\n    \"526\": {\n        name: \"cu_bizon_citizen\",\n        tag: \"Photic Zone\"\n    },\n    \"527\": {\n        name: \"aq_deserteagle_kumichodragon\",\n        tag: \"Kumicho Dragon\"\n    },\n    \"528\": {\n        name: \"aq_dualberettas_cartel\",\n        tag: \"Cartel\"\n    },\n    \"529\": {\n        name: \"aq_famas_contour\",\n        tag: \"Valence\"\n    },\n    \"530\": {\n        name: \"cu_fiveseven_augmented\",\n        tag: \"Triumvirate\"\n    },\n    \"532\": {\n        name: \"gs_glock18_award\",\n        tag: \"Royal Legion\"\n    },\n    \"533\": {\n        name: \"gs_m4a4_pioneer\",\n        tag: \"The Battlestar\"\n    },\n    \"534\": {\n        name: \"am_mac10_electricity\",\n        tag: \"Lapis Gator\"\n    },\n    \"535\": {\n        name: \"gs_mag7_praetorian\",\n        tag: \"Praetorian\"\n    },\n    \"536\": {\n        name: \"sp_mp7_impire\",\n        tag: \"Impire\"\n    },\n    \"537\": {\n        name: \"cu_nova_hyperbeast\",\n        tag: \"Hyper Beast\"\n    },\n    \"538\": {\n        name: \"cu_ssg08_necropos\",\n        tag: \"Necropos\"\n    },\n    \"539\": {\n        name: \"gs_tec9_jambiya\",\n        tag: \"Jambiya\"\n    },\n    \"540\": {\n        name: \"gs_usp_voltage\",\n        tag: \"Lead Conduit\"\n    },\n    \"541\": {\n        name: \"cu_aug_swallows\",\n        tag: \"Fleet Flock\"\n    },\n    \"542\": {\n        name: \"cu_bizon_Curse\",\n        tag: \"Judgement of Anubis\"\n    },\n    \"543\": {\n        name: \"gs_cz75a_redastor\",\n        tag: \"Red Astor\"\n    },\n    \"544\": {\n        name: \"gs_dualberettas_ventilators\",\n        tag: \"Ventilators\"\n    },\n    \"545\": {\n        name: \"sp_g3sg1_militiaorange\",\n        tag: \"Orange Crash\"\n    },\n    \"546\": {\n        name: \"gs_galilar_incenerator\",\n        tag: \"Firefight\"\n    },\n    \"547\": {\n        name: \"cu_m249_spectre\",\n        tag: \"Spectre\"\n    },\n    \"548\": {\n        name: \"cu_m4a1s_soultaker\",\n        tag: \"Chantico's Fire\"\n    },\n    \"549\": {\n        name: \"am_mp9_bioleak\",\n        tag: \"Bioleak\"\n    },\n    \"550\": {\n        name: \"hy_p2000_oceani\",\n        tag: \"Oceanic\"\n    },\n    \"551\": {\n        name: \"cu_p250_asiimov\",\n        tag: \"Asiimov\"\n    },\n    \"552\": {\n        name: \"gs_sawedoff_fubar\",\n        tag: \"Fubar\"\n    },\n    \"553\": {\n        name: \"cu_sg553_atlas\",\n        tag: \"Atlas\"\n    },\n    \"554\": {\n        name: \"gs_ssg08_armacore\",\n        tag: \"Ghost Crusader\"\n    },\n    \"555\": {\n        name: \"am_tec9_redblast\",\n        tag: \"Re-Entry\"\n    },\n    \"556\": {\n        name: \"cu_ump45_primalsaber\",\n        tag: \"Primal Saber\"\n    },\n    \"557\": {\n        name: \"cu_xm1014_spectrum\",\n        tag: \"Black Tie\"\n    },\n    \"558\": {\n        name: \"cu_bayonet_lore\",\n        tag: \"Lore\"\n    },\n    \"559\": {\n        name: \"cu_flip_lore\",\n        tag: \"Lore\"\n    },\n    \"560\": {\n        name: \"cu_gut_lore\",\n        tag: \"Lore\"\n    },\n    \"561\": {\n        name: \"cu_karam_lore\",\n        tag: \"Lore\"\n    },\n    \"562\": {\n        name: \"cu_m9_bay_lore\",\n        tag: \"Lore\"\n    },\n    \"563\": {\n        name: \"cu_bayonet_stonewash\",\n        tag: \"Black Laminate\"\n    },\n    \"564\": {\n        name: \"cu_flip_stonewash\",\n        tag: \"Black Laminate\"\n    },\n    \"565\": {\n        name: \"cu_gut_stonewash\",\n        tag: \"Black Laminate\"\n    },\n    \"566\": {\n        name: \"cu_karam_stonewash\",\n        tag: \"Black Laminate\"\n    },\n    \"567\": {\n        name: \"cu_m9_bay_stonewash\",\n        tag: \"Black Laminate\"\n    },\n    \"568\": {\n        name: \"am_emerald_marbleized\",\n        tag: \"Gamma Doppler\"\n    },\n    \"569\": {\n        name: \"am_gamma_doppler_phase1\",\n        tag: \"Gamma Doppler\"\n    },\n    \"570\": {\n        name: \"am_gamma_doppler_phase2\",\n        tag: \"Gamma Doppler\"\n    },\n    \"571\": {\n        name: \"am_gamma_doppler_phase3\",\n        tag: \"Gamma Doppler\"\n    },\n    \"572\": {\n        name: \"am_gamma_doppler_phase4\",\n        tag: \"Gamma Doppler\"\n    },\n    \"573\": {\n        name: \"gs_bayonet_autotronic\",\n        tag: \"Autotronic\"\n    },\n    \"574\": {\n        name: \"gs_flip_autotronic\",\n        tag: \"Autotronic\"\n    },\n    \"575\": {\n        name: \"gs_gut_autotronic\",\n        tag: \"Autotronic\"\n    },\n    \"576\": {\n        name: \"gs_karam_autotronic\",\n        tag: \"Autotronic\"\n    },\n    \"577\": {\n        name: \"gs_m9_bay_autotronic\",\n        tag: \"Autotronic\"\n    },\n    \"578\": {\n        name: \"hy_ocean_knife\",\n        tag: \"Bright Water\"\n    },\n    \"579\": {\n        name: \"hy_ocean_knife_90\",\n        tag: \"Bright Water\"\n    },\n    \"580\": {\n        name: \"am_marked_up\",\n        tag: \"Freehand\"\n    },\n    \"581\": {\n        name: \"am_marked_up_90\",\n        tag: \"Freehand\"\n    },\n    \"582\": {\n        name: \"am_marked_up_fine\",\n        tag: \"Freehand\"\n    },\n    \"583\": {\n        name: \"gs_aug_aristocrat\",\n        tag: \"Aristocrat\"\n    },\n    \"584\": {\n        name: \"gs_awp_phobos\",\n        tag: \"Phobos\"\n    },\n    \"585\": {\n        name: \"cu_five_seven_daimyo\",\n        tag: \"Violent Daimyo\"\n    },\n    \"586\": {\n        name: \"cu_glock_wasteland_rebel\",\n        tag: \"Wasteland Rebel\"\n    },\n    \"587\": {\n        name: \"gs_m4a1_mecha_industries\",\n        tag: \"Mecha Industries\"\n    },\n    \"588\": {\n        name: \"cu_m4a4_desolate_space\",\n        tag: \"Desolate Space\"\n    },\n    \"589\": {\n        name: \"aq_mac_10_alien_camo\",\n        tag: \"Carnivore\"\n    },\n    \"590\": {\n        name: \"aq_nova_sci_fi\",\n        tag: \"Exo\"\n    },\n    \"591\": {\n        name: \"gs_p2000_imperial_dragon\",\n        tag: \"Imperial Dragon\"\n    },\n    \"592\": {\n        name: \"gs_p250_metal_panels\",\n        tag: \"Iron Clad\"\n    },\n    \"593\": {\n        name: \"gs_p90_full_throttle\",\n        tag: \"Chopper\"\n    },\n    \"594\": {\n        name: \"gs_pp_bizon_harvester\",\n        tag: \"Harvester\"\n    },\n    \"595\": {\n        name: \"cu_r8_cybersport\",\n        tag: \"Reboot\"\n    },\n    \"596\": {\n        name: \"cu_sawed_off_lime\",\n        tag: \"Limelight\"\n    },\n    \"597\": {\n        name: \"gs_scar20_bloodsport\",\n        tag: \"Bloodsport\"\n    },\n    \"598\": {\n        name: \"cu_sg553_aerial\",\n        tag: \"Aerial\"\n    },\n    \"599\": {\n        name: \"am_tec_9_sea_salt\",\n        tag: \"Ice Cap\"\n    },\n    \"600\": {\n        name: \"cu_ak47_anarchy\",\n        tag: \"Neon Revolution\"\n    },\n    \"601\": {\n        name: \"gs_aug_syd_mead\",\n        tag: \"Syd Mead\"\n    },\n    \"602\": {\n        name: \"gs_cz75_tread\",\n        tag: \"Imprint\"\n    },\n    \"603\": {\n        name: \"aq_desert_eagle_constable\",\n        tag: \"Directive\"\n    },\n    \"604\": {\n        name: \"gs_famas_rally\",\n        tag: \"Roll Cage\"\n    },\n    \"605\": {\n        name: \"aq_five_seven_scumbria\",\n        tag: \"Scumbria\"\n    },\n    \"606\": {\n        name: \"gs_g3sg1_ventilator\",\n        tag: \"Ventilator\"\n    },\n    \"607\": {\n        name: \"cu_glock18_weasel\",\n        tag: \"Weasel\"\n    },\n    \"608\": {\n        name: \"cu_mag7_tribal\",\n        tag: \"Petroglyph\"\n    },\n    \"609\": {\n        name: \"cu_mp9_narcis\",\n        tag: \"Airlock\"\n    },\n    \"610\": {\n        name: \"hy_negev_dazzle\",\n        tag: \"Dazzle\"\n    },\n    \"611\": {\n        name: \"cu_p90_grimm\",\n        tag: \"Grim\"\n    },\n    \"612\": {\n        name: \"gs_scar20_powercore\",\n        tag: \"Powercore\"\n    },\n    \"613\": {\n        name: \"cu_sg556_triarch\",\n        tag: \"Triarch\"\n    },\n    \"614\": {\n        name: \"gs_tec9_supercharged\",\n        tag: \"Fuel Injector\"\n    },\n    \"615\": {\n        name: \"cu_ump45_metritera\",\n        tag: \"Briefing\"\n    },\n    \"616\": {\n        name: \"hy_xm1014_fractal_blue\",\n        tag: \"Slipstream\"\n    },\n    \"617\": {\n        name: \"am_blackpearl_marbleized_b\",\n        tag: \"Doppler\"\n    },\n    \"618\": {\n        name: \"am_doppler_phase2_b\",\n        tag: \"Doppler\"\n    },\n    \"619\": {\n        name: \"am_sapphire_marbleized_b\",\n        tag: \"Doppler\"\n    },\n    \"620\": {\n        name: \"cu_purple_huntsman\",\n        tag: \"Ultraviolet\"\n    },\n    \"621\": {\n        name: \"so_purple_falchion\",\n        tag: \"Ultraviolet\"\n    },\n    \"622\": {\n        name: \"am_czv2_mf\",\n        tag: \"Polymer\"\n    },\n    \"623\": {\n        name: \"aq_glock_dark-fall\",\n        tag: \"Ironwork\"\n    },\n    \"624\": {\n        name: \"cu_ssg08_dragonfire_scope\",\n        tag: \"Dragonfire\"\n    },\n    \"625\": {\n        name: \"gs_dual_berettas_golden_venice\",\n        tag: \"Royal Consorts\"\n    },\n    \"626\": {\n        name: \"gs_famas_mecha\",\n        tag: \"Mecha Industries\"\n    },\n    \"627\": {\n        name: \"gs_final_pooldeadv2\",\n        tag: \"Cirrus\"\n    },\n    \"628\": {\n        name: \"gs_g3sg1_viper_yellow\",\n        tag: \"Stinger\"\n    },\n    \"629\": {\n        name: \"cu_galil_ar-camo\",\n        tag: \"Black Sand\"\n    },\n    \"630\": {\n        name: \"aa_hide-mp9\",\n        tag: \"Sand Scale\"\n    },\n    \"631\": {\n        name: \"cu_m4a1_flashback\",\n        tag: \"Flashback\"\n    },\n    \"632\": {\n        name: \"gs_m4a4_sector\",\n        tag: \"Buzz Kill\"\n    },\n    \"633\": {\n        name: \"am_mag7_malform\",\n        tag: \"Sonar\"\n    },\n    \"634\": {\n        name: \"am_nova_sand\",\n        tag: \"Gila\"\n    },\n    \"635\": {\n        name: \"gs_p2000-sport\",\n        tag: \"Turf\"\n    },\n    \"636\": {\n        name: \"gs_p90_shallow_grave\",\n        tag: \"Shallow Grave\"\n    },\n    \"637\": {\n        name: \"cu_usp_cyrex\",\n        tag: \"Cyrex\"\n    },\n    \"638\": {\n        name: \"cu_wp_sawedoff\",\n        tag: \"Wasteland Princess\"\n    },\n    \"639\": {\n        name: \"gs_ak47_bloodsport\",\n        tag: \"Bloodsport\"\n    },\n    \"640\": {\n        name: \"cu_awp_psychopath\",\n        tag: \"Fever Dream\"\n    },\n    \"641\": {\n        name: \"hy_bizon_torn_green\",\n        tag: \"Jungle Slipstream\"\n    },\n    \"642\": {\n        name: \"cu_blueprint_scar\",\n        tag: \"Blueprint\"\n    },\n    \"643\": {\n        name: \"gs_cz_snakes_purple\",\n        tag: \"Xiangliu\"\n    },\n    \"644\": {\n        name: \"gs_m4a1_decimator\",\n        tag: \"Decimator\"\n    },\n    \"645\": {\n        name: \"cu_desert_eagle_corroden\",\n        tag: \"Oxide Blaze\"\n    },\n    \"646\": {\n        name: \"cu_fiveseven_vein\",\n        tag: \"Capillary\"\n    },\n    \"647\": {\n        name: \"sp_galil_wave\",\n        tag: \"Crimson Tsunami\"\n    },\n    \"648\": {\n        name: \"sp_m249_frog_original\",\n        tag: \"Emerald Poison Dart\"\n    },\n    \"649\": {\n        name: \"sp_mp7_tribal_yellow\",\n        tag: \"Akoben\"\n    },\n    \"650\": {\n        name: \"am_p250_sputnik\",\n        tag: \"Ripple\"\n    },\n    \"651\": {\n        name: \"aa_mac10_the_last_dive\",\n        tag: \"Last Dive\"\n    },\n    \"652\": {\n        name: \"gs_ump_abyss\",\n        tag: \"Scaffold\"\n    },\n    \"653\": {\n        name: \"cu_usps_noir\",\n        tag: \"Neo-Noir\"\n    },\n    \"654\": {\n        name: \"aq_xm_leaf_fade\",\n        tag: \"Seasons\"\n    },\n    \"655\": {\n        name: \"aq_sawedoff_zander2\",\n        tag: \"Zander\"\n    },\n    \"656\": {\n        name: \"gs_ak_colony01_red\",\n        tag: \"Orbit Mk01\"\n    },\n    \"657\": {\n        name: \"cu_usps_blueprint\",\n        tag: \"Blueprint\"\n    },\n    \"658\": {\n        name: \"gs_dualberettas_cobra\",\n        tag: \"Cobra Strike\"\n    },\n    \"659\": {\n        name: \"sp_famas_macabre\",\n        tag: \"Macabre\"\n    },\n    \"660\": {\n        name: \"cu_fiveseven_hyperbeast\",\n        tag: \"Hyper Beast\"\n    },\n    \"661\": {\n        name: \"cu_galil_candychaos\",\n        tag: \"Sugar Rush\"\n    },\n    \"662\": {\n        name: \"cu_awp_hannya\",\n        tag: \"Oni Taiji\"\n    },\n    \"663\": {\n        name: \"cu_m4a1s_metritera\",\n        tag: \"Briefing\"\n    },\n    \"664\": {\n        name: \"cu_m4a4_hellfire\",\n        tag: \"Hellfire\"\n    },\n    \"665\": {\n        name: \"am_mac10_aloha\",\n        tag: \"Aloha\"\n    },\n    \"666\": {\n        name: \"am_mag7_caustic\",\n        tag: \"Hard Water\"\n    },\n    \"667\": {\n        name: \"cu_p2000_hunter\",\n        tag: \"Woodsman\"\n    },\n    \"668\": {\n        name: \"cu_p250_axiom\",\n        tag: \"Red Rock\"\n    },\n    \"669\": {\n        name: \"hy_p90_barebones_blue\",\n        tag: \"Death Grip\"\n    },\n    \"670\": {\n        name: \"cu_ssg08_deathshead\",\n        tag: \"Death's Head\"\n    },\n    \"671\": {\n        name: \"aq_tec9_chalk_pattern\",\n        tag: \"Cut Out\"\n    },\n    \"672\": {\n        name: \"aq_ump45_flameflower\",\n        tag: \"Metal Flowers\"\n    },\n    \"673\": {\n        name: \"aq_sawed-off_flower\",\n        tag: \"Morris\"\n    },\n    \"674\": {\n        name: \"cu_aug_orange_triangle\",\n        tag: \"Triqua\"\n    },\n    \"675\": {\n        name: \"gs_ak47_empress\",\n        tag: \"The Empress\"\n    },\n    \"676\": {\n        name: \"cu_bizon_all_in\",\n        tag: \"High Roller\"\n    },\n    \"677\": {\n        name: \"gs_g3sg1_cetme_redux\",\n        tag: \"Hunter\"\n    },\n    \"678\": {\n        name: \"cu_p250_cybercroc\",\n        tag: \"See Ya Later\"\n    },\n    \"679\": {\n        name: \"cu_mp9_goo\",\n        tag: \"Goo\"\n    },\n    \"680\": {\n        name: \"cu_glock_indigo\",\n        tag: \"Off World\"\n    },\n    \"681\": {\n        name: \"gs_m4a1_shatter\",\n        tag: \"Leaded Glass\"\n    },\n    \"682\": {\n        name: \"am_mac10_oceani\",\n        tag: \"Oceanic\"\n    },\n    \"683\": {\n        name: \"gs_r8_llamacannon\",\n        tag: \"Llama Cannon\"\n    },\n    \"684\": {\n        name: \"cu_tec9_cracked_opal\",\n        tag: \"Cracked Opal\"\n    },\n    \"685\": {\n        name: \"hy_scar20_jungle_slipstream\",\n        tag: \"Jungle Slipstream\"\n    },\n    \"686\": {\n        name: \"gs_sg553_phantom\",\n        tag: \"Phantom\"\n    },\n    \"687\": {\n        name: \"gs_cz75_tacticat\",\n        tag: \"Tacticat\"\n    },\n    \"688\": {\n        name: \"cu_ump45_x-ray_machine\",\n        tag: \"Exposure\"\n    },\n    \"689\": {\n        name: \"aq_xm1014_ziggy_anarchy\",\n        tag: \"Ziggy\"\n    },\n    \"690\": {\n        name: \"gs_aug_stymphalian_birds\",\n        tag: \"Stymphalian\"\n    },\n    \"691\": {\n        name: \"gs_awp_death\",\n        tag: \"Mortis\"\n    },\n    \"692\": {\n        name: \"cu_bizon_riot\",\n        tag: \"Night Riot\"\n    },\n    \"693\": {\n        name: \"gs_fiveseven_hot_rod_violet\",\n        tag: \"Flame Test\"\n    },\n    \"694\": {\n        name: \"aa_glock_18_urban_moon_fever\",\n        tag: \"Moonrise\"\n    },\n    \"695\": {\n        name: \"cu_m4a4_neo_noir\",\n        tag: \"Neo-Noir\"\n    },\n    \"696\": {\n        name: \"gs_mp7_bloodsport\",\n        tag: \"Bloodsport\"\n    },\n    \"697\": {\n        name: \"cu_mp9_black_sand\",\n        tag: \"Black Sand\"\n    },\n    \"698\": {\n        name: \"sp_negev_lionfish\",\n        tag: \"Lionfish\"\n    },\n    \"699\": {\n        name: \"gs_nova_anchorite\",\n        tag: \"Wild Six\"\n    },\n    \"700\": {\n        name: \"cu_p2000_urban_hazard\",\n        tag: \"Urban Hazard\"\n    },\n    \"701\": {\n        name: \"gs_revolver_tread\",\n        tag: \"Grip\"\n    },\n    \"702\": {\n        name: \"sp_sg533_aloha\",\n        tag: \"Aloha\"\n    },\n    \"703\": {\n        name: \"aq_mag7_swag7\",\n        tag: \"SWAG-7\"\n    },\n    \"704\": {\n        name: \"cu_ump45_white_fang\",\n        tag: \"Arctic Wolf\"\n    },\n    \"705\": {\n        name: \"cu_usp_cut\",\n        tag: \"Cortex\"\n    },\n    \"706\": {\n        name: \"cu_xm1014_oxide_blaze\",\n        tag: \"Oxide Blaze\"\n    },\n    \"707\": {\n        name: \"cu_ak_neon_rider\",\n        tag: \"Neon Rider\"\n    },\n    \"708\": {\n        name: \"hy_aug_torn_orange\",\n        tag: \"Amber Slipstream\"\n    },\n    \"709\": {\n        name: \"cu_cz75_eco\",\n        tag: \"Eco\"\n    },\n    \"710\": {\n        name: \"sp_elites_winter_raider\",\n        tag: \"Shred\"\n    },\n    \"711\": {\n        name: \"gs_deagle_aggressor\",\n        tag: \"Code Red\"\n    },\n    \"712\": {\n        name: \"gs_g3sg1_buccaneer\",\n        tag: \"High Seas\"\n    },\n    \"713\": {\n        name: \"gs_glock_thunder_dust\",\n        tag: \"Warhawk\"\n    },\n    \"714\": {\n        name: \"cu_m4a1s_nightmare\",\n        tag: \"Nightmare\"\n    },\n    \"715\": {\n        name: \"cu_mp9_vein\",\n        tag: \"Capillary\"\n    },\n    \"716\": {\n        name: \"cu_nova_toy_soldier\",\n        tag: \"Toy Soldier\"\n    },\n    \"717\": {\n        name: \"gs_p90_tread\",\n        tag: \"Traction\"\n    },\n    \"718\": {\n        name: \"am_awp_pawpaw\",\n        tag: \"PAW\"\n    },\n    \"719\": {\n        name: \"gs_powercore_mp7\",\n        tag: \"Powercore\"\n    },\n    \"720\": {\n        name: \"cu_sawedoff_devourer\",\n        tag: \"Devourer\"\n    },\n    \"721\": {\n        name: \"cu_r8_survivalist\",\n        tag: \"Survivalist\"\n    },\n    \"722\": {\n        name: \"cu_tec9_snake\",\n        tag: \"Snek-9\"\n    },\n    \"723\": {\n        name: \"cu_famas_owl_orange\",\n        tag: \"Eye of Athena\"\n    },\n    \"724\": {\n        name: \"cu_ak_island_floral\",\n        tag: \"Wild Lotus\"\n    },\n    \"725\": {\n        name: \"hy_bloom_red\",\n        tag: \"Day Lily\"\n    },\n    \"726\": {\n        name: \"sp_bloom_orange\",\n        tag: \"Sunset Lily\"\n    },\n    \"727\": {\n        name: \"am_bloom_blue\",\n        tag: \"Midnight Lily\"\n    },\n    \"728\": {\n        name: \"sp_bud_green\",\n        tag: \"Teal Blossom\"\n    },\n    \"729\": {\n        name: \"hy_bud_red\",\n        tag: \"Crimson Blossom\"\n    },\n    \"730\": {\n        name: \"sp_bud_blue\",\n        tag: \"Dark Blossom\"\n    },\n    \"731\": {\n        name: \"hy_leaf_green\",\n        tag: \"Banana Leaf\"\n    },\n    \"732\": {\n        name: \"hy_leaf_blue\",\n        tag: \"Synth Leaf\"\n    },\n    \"733\": {\n        name: \"sp_leaf_orange\",\n        tag: \"Rust Leaf\"\n    },\n    \"734\": {\n        name: \"cu_mp9_island_floral\",\n        tag: \"Wild Lily\"\n    },\n    \"735\": {\n        name: \"sp_nightstripe\",\n        tag: \"Night Stripe\"\n    },\n    \"736\": {\n        name: \"gs_awp_enamel\",\n        tag: \"The Prince\"\n    },\n    \"737\": {\n        name: \"gs_mag7_glass\",\n        tag: \"Cinquedea\"\n    },\n    \"738\": {\n        name: \"hy_murano_orange\",\n        tag: \"Orange Murano\"\n    },\n    \"739\": {\n        name: \"am_murano_violet\",\n        tag: \"Violet Murano\"\n    },\n    \"740\": {\n        name: \"hy_murano_blue\",\n        tag: \"Navy Murano\"\n    },\n    \"741\": {\n        name: \"am_ren_dark\",\n        tag: \"Dark Filigree\"\n    },\n    \"742\": {\n        name: \"am_ren_red\",\n        tag: \"Red Filigree\"\n    },\n    \"743\": {\n        name: \"hy_ren_orange\",\n        tag: \"Orange Filigree\"\n    },\n    \"744\": {\n        name: \"am_veneto_red\",\n        tag: \"Baroque Red\"\n    },\n    \"745\": {\n        name: \"hy_veneto_purple\",\n        tag: \"Baroque Purple\"\n    },\n    \"746\": {\n        name: \"am_veneto2\",\n        tag: \"Baroque Orange\"\n    },\n    \"747\": {\n        name: \"cu_dual_elites_rally\",\n        tag: \"Twin Turbo\"\n    },\n    \"748\": {\n        name: \"gs_mac10_checker\",\n        tag: \"Calf Skin\"\n    },\n    \"749\": {\n        name: \"gs_p250_checker\",\n        tag: \"Vino Primo\"\n    },\n    \"750\": {\n        name: \"cu_sg553_rally\",\n        tag: \"Integrale\"\n    },\n    \"751\": {\n        name: \"gs_ssg08_checker\",\n        tag: \"Hand Brake\"\n    },\n    \"752\": {\n        name: \"aa_fade_mp7\",\n        tag: \"Fade\"\n    },\n    \"753\": {\n        name: \"sp_tape_short_rally\",\n        tag: \"Dirt Drop\"\n    },\n    \"754\": {\n        name: \"aq_steel_inferno\",\n        tag: \"Rust Coat\"\n    },\n    \"755\": {\n        name: \"hy_splatter3\",\n        tag: \"Slide\"\n    },\n    \"756\": {\n        name: \"gs_awp_gungnir\",\n        tag: \"Gungnir\"\n    },\n    \"757\": {\n        name: \"am_jorm_green\",\n        tag: \"Emerald Jörmungandr\"\n    },\n    \"758\": {\n        name: \"am_jorm_orange\",\n        tag: \"Flame Jörmungandr\"\n    },\n    \"759\": {\n        name: \"am_jorm_blue\",\n        tag: \"Astral Jörmungandr\"\n    },\n    \"760\": {\n        name: \"am_knots_silver\",\n        tag: \"Frost Borre\"\n    },\n    \"761\": {\n        name: \"am_knots_brown\",\n        tag: \"Copper Borre\"\n    },\n    \"762\": {\n        name: \"so_rune_stone\",\n        tag: \"Red Stone\"\n    },\n    \"763\": {\n        name: \"gs_negev_thor\",\n        tag: \"Mjölnir\"\n    },\n    \"764\": {\n        name: \"gs_deagle_fennec\",\n        tag: \"Fennec Fox\"\n    },\n    \"765\": {\n        name: \"aa_desert_bloom_bright\",\n        tag: \"Desert Blossom\"\n    },\n    \"775\": {\n        name: \"hy_blueprint_white\",\n        tag: \"Facility Sketch\"\n    },\n    \"776\": {\n        name: \"hy_blueprint_aqua\",\n        tag: \"Facility Negative\"\n    },\n    \"777\": {\n        name: \"hy_blueprint_red\",\n        tag: \"Facility Draft\"\n    },\n    \"778\": {\n        name: \"hy_blueprint_bluered\",\n        tag: \"Facility Dark\"\n    },\n    \"779\": {\n        name: \"am_circuitboard_orange\",\n        tag: \"Random Access\"\n    },\n    \"780\": {\n        name: \"am_circuitboard_silver\",\n        tag: \"Mainframe\"\n    },\n    \"781\": {\n        name: \"am_circuitboard_aqua\",\n        tag: \"Co-Processor\"\n    },\n    \"782\": {\n        name: \"am_circuitboard_green\",\n        tag: \"Motherboard\"\n    },\n    \"783\": {\n        name: \"hy_ducts_yellow\",\n        tag: \"Bulkhead\"\n    },\n    \"784\": {\n        name: \"hy_ducts_green\",\n        tag: \"Coolant\"\n    },\n    \"785\": {\n        name: \"hy_ducts_grey\",\n        tag: \"Mandrel\"\n    },\n    \"786\": {\n        name: \"hy_ducts_blue\",\n        tag: \"Exchanger\"\n    },\n    \"787\": {\n        name: \"hy_nuclear_hotorange\",\n        tag: \"Core Breach\"\n    },\n    \"788\": {\n        name: \"hy_nuclear_skulls_redblue\",\n        tag: \"Acheron\"\n    },\n    \"789\": {\n        name: \"am_nuclear_skulls_green\",\n        tag: \"Nuclear Garden\"\n    },\n    \"790\": {\n        name: \"hy_nuclear_skulls_aqua\",\n        tag: \"Cold Fusion\"\n    },\n    \"791\": {\n        name: \"gs_tec9_envoy\",\n        tag: \"Remote Control\"\n    },\n    \"792\": {\n        name: \"gs_m4a1s_operator\",\n        tag: \"Control Panel\"\n    },\n    \"793\": {\n        name: \"hy_red_hex\",\n        tag: \"Converter\"\n    },\n    \"794\": {\n        name: \"sp_mesh_safetyblack\",\n        tag: \"Sweeper\"\n    },\n    \"795\": {\n        name: \"hy_mesh_safetyorange\",\n        tag: \"Safety Net\"\n    },\n    \"796\": {\n        name: \"sp_mesh_safetyred\",\n        tag: \"Check Engine\"\n    },\n    \"797\": {\n        name: \"aa_vertigo_red\",\n        tag: \"Brake Light\"\n    },\n    \"798\": {\n        name: \"so_orange_accents3\",\n        tag: \"Nitro\"\n    },\n    \"799\": {\n        name: \"aa_vertigo_blue\",\n        tag: \"High Beam\"\n    },\n    \"800\": {\n        name: \"hy_labrat_mp5\",\n        tag: \"Lab Rats\"\n    },\n    \"801\": {\n        name: \"cu_ak47_asiimov\",\n        tag: \"Asiimov\"\n    },\n    \"802\": {\n        name: \"cu_ump_arrows\",\n        tag: \"Momentum\"\n    },\n    \"803\": {\n        name: \"cu_awp_neonoir\",\n        tag: \"Neo-Noir\"\n    },\n    \"804\": {\n        name: \"gs_mp9_colony01\",\n        tag: \"Modest Threat\"\n    },\n    \"805\": {\n        name: \"gs_deagle_mecha\",\n        tag: \"Mecha Industries\"\n    },\n    \"806\": {\n        name: \"gs_g3sg1_savage\",\n        tag: \"Scavenger\"\n    },\n    \"807\": {\n        name: \"hy_galil_signal_red\",\n        tag: \"Signal\"\n    },\n    \"808\": {\n        name: \"cu_glock18_corroden\",\n        tag: \"Oxide Blaze\"\n    },\n    \"809\": {\n        name: \"gs_nova_hunter_brute\",\n        tag: \"Wood Fired\"\n    },\n    \"810\": {\n        name: \"gs_mp5_festival_drip\",\n        tag: \"Phosphor\"\n    },\n    \"811\": {\n        name: \"gs_m4a4_chopper_ghost\",\n        tag: \"Magnesium\"\n    },\n    \"812\": {\n        name: \"gs_mac10_exo_pipes\",\n        tag: \"Pipe Down\"\n    },\n    \"813\": {\n        name: \"aa_p250_gravediggers\",\n        tag: \"Nevermore\"\n    },\n    \"814\": {\n        name: \"cu_sawedoff_black_sand\",\n        tag: \"Black Sand\"\n    },\n    \"815\": {\n        name: \"gs_sg553_over_heated\",\n        tag: \"Danger Close\"\n    },\n    \"816\": {\n        name: \"gs_tec9_fubar\",\n        tag: \"Fubar\"\n    },\n    \"817\": {\n        name: \"cu_usp_flashback\",\n        tag: \"Flashback\"\n    },\n    \"818\": {\n        name: \"am_ddpat_purple\",\n        tag: \"Purple DDPAT\"\n    },\n    \"819\": {\n        name: \"gs_awp_hydra\",\n        tag: \"Desert Hydra\"\n    },\n    \"820\": {\n        name: \"am_mirage_flowers_metalic\",\n        tag: \"Music Box\"\n    },\n    \"821\": {\n        name: \"am_moro_textile_bright\",\n        tag: \"Elegant Vines\"\n    },\n    \"822\": {\n        name: \"am_navy_shine\",\n        tag: \"Navy Sheen\"\n    },\n    \"823\": {\n        name: \"gs_aug_sand_storm\",\n        tag: \"Sand Storm\"\n    },\n    \"824\": {\n        name: \"sp_dry_wood\",\n        tag: \"Drift Wood\"\n    },\n    \"825\": {\n        name: \"sp_desert_skulls_dawn\",\n        tag: \"Drought\"\n    },\n    \"826\": {\n        name: \"sp_mirage_flowers_tan\",\n        tag: \"Sienna Damask\"\n    },\n    \"827\": {\n        name: \"sp_moro_carving_burnt\",\n        tag: \"Humidor\"\n    },\n    \"828\": {\n        name: \"sp_moro_textile_green_vine\",\n        tag: \"Verdant Growth\"\n    },\n    \"829\": {\n        name: \"hy_lizard_skin\",\n        tag: \"Anolis\"\n    },\n    \"835\": {\n        name: \"sp_famas_ghost_insects\",\n        tag: \"Crypsis\"\n    },\n    \"836\": {\n        name: \"cu_ak47_aztec\",\n        tag: \"Uncharted\"\n    },\n    \"837\": {\n        name: \"cu_five_seven_angry\",\n        tag: \"Angry Mob\"\n    },\n    \"838\": {\n        name: \"cu_awp_viper\",\n        tag: \"Atheris\"\n    },\n    \"839\": {\n        name: \"cu_tec9_bamboo\",\n        tag: \"Bamboozle\"\n    },\n    \"840\": {\n        name: \"gs_mac10_fish_bait\",\n        tag: \"Whitefish\"\n    },\n    \"841\": {\n        name: \"gs_deagle_exo\",\n        tag: \"Light Rail\"\n    },\n    \"842\": {\n        name: \"sp_galil_akoben\",\n        tag: \"Akoben\"\n    },\n    \"843\": {\n        name: \"cu_revolver_oppressor\",\n        tag: \"Skull Crusher\"\n    },\n    \"844\": {\n        name: \"gs_m4a4_emperor\",\n        tag: \"The Emperor\"\n    },\n    \"845\": {\n        name: \"cu_aug_momentum\",\n        tag: \"Momentum\"\n    },\n    \"846\": {\n        name: \"gs_mp5sd_astromatic\",\n        tag: \"Gauss\"\n    },\n    \"847\": {\n        name: \"cu_mp7_racketeer\",\n        tag: \"Mischief\"\n    },\n    \"848\": {\n        name: \"aq_p250_verdigris\",\n        tag: \"Verdigris\"\n    },\n    \"849\": {\n        name: \"cu_p90_offworld\",\n        tag: \"Off World\"\n    },\n    \"850\": {\n        name: \"cu_xm1014_incinerator\",\n        tag: \"Incinegator\"\n    },\n    \"851\": {\n        name: \"aa_ump45_moonrise_sunset\",\n        tag: \"Moonrise\"\n    },\n    \"852\": {\n        name: \"am_doppler_phase1_widow\",\n        tag: \"Doppler\"\n    },\n    \"853\": {\n        name: \"am_doppler_phase2_widow\",\n        tag: \"Doppler\"\n    },\n    \"854\": {\n        name: \"am_doppler_phase3_widow\",\n        tag: \"Doppler\"\n    },\n    \"855\": {\n        name: \"am_doppler_phase4_widow\",\n        tag: \"Doppler\"\n    },\n    \"856\": {\n        name: \"am_marble_fade_widow\",\n        tag: \"Marble Fade\"\n    },\n    \"857\": {\n        name: \"aq_damascus_prisma\",\n        tag: \"Damascus Steel\"\n    },\n    \"858\": {\n        name: \"aq_damascus_widow\",\n        tag: \"Damascus Steel\"\n    },\n    \"859\": {\n        name: \"am_crystallized_green\",\n        tag: \"Emerald Quartz\"\n    },\n    \"860\": {\n        name: \"hy_gelpen_dark\",\n        tag: \"Pyre\"\n    },\n    \"861\": {\n        name: \"sp_asgard_wall\",\n        tag: \"Barricade\"\n    },\n    \"862\": {\n        name: \"am_crystallized_dark_green\",\n        tag: \"Moss Quartz\"\n    },\n    \"863\": {\n        name: \"sp_knots_blue\",\n        tag: \"Night Borre\"\n    },\n    \"864\": {\n        name: \"so_red_sg553\",\n        tag: \"Candy Apple\"\n    },\n    \"865\": {\n        name: \"hy_canals_tile\",\n        tag: \"Stone Mosaico\"\n    },\n    \"866\": {\n        name: \"sp_spray_water\",\n        tag: \"Canal Spray\"\n    },\n    \"867\": {\n        name: \"am_stained_glass\",\n        tag: \"Stained Glass\"\n    },\n    \"868\": {\n        name: \"hy_flowers_stmarc\",\n        tag: \"Sea Calico\"\n    },\n    \"869\": {\n        name: \"sp_palm_sunset\",\n        tag: \"Sundown\"\n    },\n    \"870\": {\n        name: \"sp_palm_green\",\n        tag: \"Jungle Thicket\"\n    },\n    \"871\": {\n        name: \"sp_twigs_beach\",\n        tag: \"Surfwood\"\n    },\n    \"872\": {\n        name: \"hy_bamboo_stmarc\",\n        tag: \"Bamboo Garden\"\n    },\n    \"873\": {\n        name: \"so_aqua_stmarc\",\n        tag: \"Seabird\"\n    },\n    \"879\": {\n        name: \"aa_fade_ump\",\n        tag: \"Fade\"\n    },\n    \"880\": {\n        name: \"hy_desert_bloom\",\n        tag: \"Parched\"\n    },\n    \"884\": {\n        name: \"cu_bizon_road_warrior\",\n        tag: \"Embargo\"\n    },\n    \"885\": {\n        name: \"gs_ak47_nibbler\",\n        tag: \"Rat Rod\"\n    },\n    \"886\": {\n        name: \"cu_aug_whitefang\",\n        tag: \"Arctic Wolf\"\n    },\n    \"887\": {\n        name: \"cu_awp_virus\",\n        tag: \"Containment Breach\"\n    },\n    \"888\": {\n        name: \"gs_mp5_etch\",\n        tag: \"Acid Wash\"\n    },\n    \"889\": {\n        name: \"gs_tec9_decimator\",\n        tag: \"Decimator\"\n    },\n    \"890\": {\n        name: \"cu_nova_featherswing\",\n        tag: \"Plume\"\n    },\n    \"891\": {\n        name: \"cu_g3sg1_blacksand\",\n        tag: \"Black Sand\"\n    },\n    \"892\": {\n        name: \"gs_r8_memento\",\n        tag: \"Memento\"\n    },\n    \"893\": {\n        name: \"cu_mp7_replica\",\n        tag: \"Neon Ply\"\n    },\n    \"894\": {\n        name: \"cu_p2000_obsidian\",\n        tag: \"Obsidian\"\n    },\n    \"895\": {\n        name: \"gs_dual_elites_rose\",\n        tag: \"Balance\"\n    },\n    \"896\": {\n        name: \"sp_scar20_striker_dust\",\n        tag: \"Torn\"\n    },\n    \"897\": {\n        name: \"cu_sg553_reactor\",\n        tag: \"Colony IV\"\n    },\n    \"898\": {\n        name: \"gs_mac10_stalker\",\n        tag: \"Stalker\"\n    },\n    \"899\": {\n        name: \"cu_ssg08_tickler\",\n        tag: \"Bloodshot\"\n    },\n    \"900\": {\n        name: \"gs_m249_warbird_veteran\",\n        tag: \"Warbird\"\n    },\n    \"902\": {\n        name: \"aq_m249_aztec\",\n        tag: \"Aztec\"\n    },\n    \"903\": {\n        name: \"gs_dual_elites_classic\",\n        tag: \"Elite 1.6\"\n    },\n    \"904\": {\n        name: \"cu_famas_nuke_tension\",\n        tag: \"Decommissioned\"\n    },\n    \"905\": {\n        name: \"cu_tec9_flash\",\n        tag: \"Flash Out\"\n    },\n    \"906\": {\n        name: \"cu_fiveseven_gsg9\",\n        tag: \"Buddy\"\n    },\n    \"907\": {\n        name: \"gs_p250_inferno\",\n        tag: \"Inferno\"\n    },\n    \"908\": {\n        name: \"gs_mac10_dust_crate\",\n        tag: \"Classic Crate\"\n    },\n    \"909\": {\n        name: \"gs_mag7_popdog\",\n        tag: \"Popdog\"\n    },\n    \"910\": {\n        name: \"cu_mp9_hydra\",\n        tag: \"Hydra\"\n    },\n    \"911\": {\n        name: \"cu_p90_nostalgia\",\n        tag: \"Nostalgia\"\n    },\n    \"913\": {\n        name: \"am_aug_death_by_doggy\",\n        tag: \"Death by Puppy\"\n    },\n    \"914\": {\n        name: \"cu_scar_assault\",\n        tag: \"Assault\"\n    },\n    \"915\": {\n        name: \"gs_mp5_fbi\",\n        tag: \"Agent\"\n    },\n    \"916\": {\n        name: \"cu_ump_bomb\",\n        tag: \"Plastique\"\n    },\n    \"917\": {\n        name: \"cu_awp_wildfire\",\n        tag: \"Wildfire\"\n    },\n    \"918\": {\n        name: \"cu_glock_hero\",\n        tag: \"Sacrifice\"\n    },\n    \"919\": {\n        name: \"gs_famas_legacy_gold\",\n        tag: \"Commemoration\"\n    },\n    \"920\": {\n        name: \"hy_veneto_tan\",\n        tag: \"Boroque Sand\"\n    },\n    \"921\": {\n        name: \"gs_ak47_gold_arabesque\",\n        tag: \"Gold Arabesque\"\n    },\n    \"922\": {\n        name: \"am_lizard_red\",\n        tag: \"Orange Anolis\"\n    },\n    \"923\": {\n        name: \"gs_mp5_neon_flektarn\",\n        tag: \"Oxide Oasis\"\n    },\n    \"924\": {\n        name: \"hy_brush_camo_tan\",\n        tag: \"Desert Brush\"\n    },\n    \"925\": {\n        name: \"hy_ddpat_desert\",\n        tag: \"Desert DDPAT\"\n    },\n    \"926\": {\n        name: \"hy_ddpat_urban_red\",\n        tag: \"Red DDPAT\"\n    },\n    \"927\": {\n        name: \"hy_dry_wood\",\n        tag: \"Spalted Wood\"\n    },\n    \"928\": {\n        name: \"hy_desert_multicam\",\n        tag: \"Black & Tan\"\n    },\n    \"929\": {\n        name: \"hy_torn_camo_paints\",\n        tag: \"Quick Sand\"\n    },\n    \"930\": {\n        name: \"sp_moro_carving_lightblue\",\n        tag: \"New Roots\"\n    },\n    \"931\": {\n        name: \"sp_moro_carving_yellow\",\n        tag: \"Old Roots\"\n    },\n    \"932\": {\n        name: \"sp_moro_textile_purple_yellow\",\n        tag: \"Withered Vine\"\n    },\n    \"933\": {\n        name: \"sp_palm_night\",\n        tag: \"Midnight Palm\"\n    },\n    \"934\": {\n        name: \"sp_desert_skulls\",\n        tag: \"Bleached\"\n    },\n    \"935\": {\n        name: \"sp_zebracam_red\",\n        tag: \"Prey\"\n    },\n    \"941\": {\n        name: \"cu_ak-47_phantom_disruptor\",\n        tag: \"Phantom Disruptor\"\n    },\n    \"942\": {\n        name: \"gs_aug_thunderstorm\",\n        tag: \"Tom Cat\"\n    },\n    \"943\": {\n        name: \"cu_awp_vein\",\n        tag: \"Capillary\"\n    },\n    \"944\": {\n        name: \"cu_cz75_cerakote\",\n        tag: \"Distressed\"\n    },\n    \"945\": {\n        name: \"cu_deagle_replica\",\n        tag: \"Blue Ply\"\n    },\n    \"946\": {\n        name: \"cu_m4a1s_csgo2048\",\n        tag: \"Player Two\"\n    },\n    \"947\": {\n        name: \"cu_mac10_nacre\",\n        tag: \"Disco Tech\"\n    },\n    \"948\": {\n        name: \"gs_mag7_justice\",\n        tag: \"Justice\"\n    },\n    \"949\": {\n        name: \"cu_mp5_desert_strike\",\n        tag: \"Desert Strike\"\n    },\n    \"950\": {\n        name: \"cu_negev_prototype\",\n        tag: \"Prototype\"\n    },\n    \"951\": {\n        name: \"aq_p2000_acid_clover\",\n        tag: \"Acid Etched\"\n    },\n    \"952\": {\n        name: \"gs_r8_leviathan\",\n        tag: \"Bone Forged\"\n    },\n    \"953\": {\n        name: \"cu_sawedoff_apocalypto\",\n        tag: \"Apocalypto\"\n    },\n    \"954\": {\n        name: \"gs_scar20_enforcer\",\n        tag: \"Enforcer\"\n    },\n    \"955\": {\n        name: \"cu_sg553_darkwing\",\n        tag: \"Darkwing\"\n    },\n    \"956\": {\n        name: \"cu_ssg08_fever_dream\",\n        tag: \"Fever Dream\"\n    },\n    \"957\": {\n        name: \"cu_glock18_warmaiden\",\n        tag: \"Bullet Queen\"\n    },\n    \"958\": {\n        name: \"cu_negev_ultralight\",\n        tag: \"Ultralight\"\n    },\n    \"959\": {\n        name: \"cu_ak47_anubis\",\n        tag: \"Legion of Anubis\"\n    },\n    \"960\": {\n        name: \"aq_p2000_lost_world\",\n        tag: \"Gnarled\"\n    },\n    \"961\": {\n        name: \"cu_mag7_monster_call\",\n        tag: \"Monster Call\"\n    },\n    \"962\": {\n        name: \"cu_deag_printstream\",\n        tag: \"Printstream\"\n    },\n    \"963\": {\n        name: \"cu_glock_eyecontact\",\n        tag: \"Vogue\"\n    },\n    \"964\": {\n        name: \"gs_tec9_guerilla\",\n        tag: \"Brother\"\n    },\n    \"965\": {\n        name: \"cu_mac10_isoonna\",\n        tag: \"Allure\"\n    },\n    \"966\": {\n        name: \"gs_sg553_rusty\",\n        tag: \"Ol' Rusty\"\n    },\n    \"967\": {\n        name: \"cu_ssg08_mainframe\",\n        tag: \"Mainframe 001\"\n    },\n    \"968\": {\n        name: \"cu_p250_cassette\",\n        tag: \"Cassette\"\n    },\n    \"969\": {\n        name: \"gs_p90_container\",\n        tag: \"Freight\"\n    },\n    \"970\": {\n        name: \"cu_xm1014_amulet_blue\",\n        tag: \"Entombed\"\n    },\n    \"971\": {\n        name: \"cu_m4a4_queenfairy\",\n        tag: \"Tooth Fairy\"\n    },\n    \"972\": {\n        name: \"gs_galil_phoenix\",\n        tag: \"Connexion\"\n    },\n    \"973\": {\n        name: \"gs_bizon_hellraider\",\n        tag: \"Runic\"\n    },\n    \"974\": {\n        name: \"gs_mp5sd_wasteland_legacy\",\n        tag: \"Kitbash\"\n    },\n    \"975\": {\n        name: \"gs_awp_exoskeleton\",\n        tag: \"Exoskeleton\"\n    },\n    \"976\": {\n        name: \"gs_cz75_vendetta\",\n        tag: \"Vendetta\"\n    },\n    \"977\": {\n        name: \"hy_p90_dino_rampage\",\n        tag: \"Cocoa Rampage\"\n    },\n    \"978\": {\n        name: \"gs_dual_elites_dezastre\",\n        tag: \"Dezastre\"\n    },\n    \"979\": {\n        name: \"cu_five_seven_diary\",\n        tag: \"Fairy Tale\"\n    },\n    \"980\": {\n        name: \"gs_g3sg1_disrupt\",\n        tag: \"Digital Mesh\"\n    },\n    \"981\": {\n        name: \"gs_galil_vandal\",\n        tag: \"Vandal\"\n    },\n    \"982\": {\n        name: \"cu_p250_infect\",\n        tag: \"Contaminant\"\n    },\n    \"983\": {\n        name: \"cu_m249_deep_relief\",\n        tag: \"Deep Relief\"\n    },\n    \"984\": {\n        name: \"cu_m4a1s_printstream\",\n        tag: \"Printstream\"\n    },\n    \"985\": {\n        name: \"cu_m4a4_cyberpunk\",\n        tag: \"Cyber Security\"\n    },\n    \"986\": {\n        name: \"gs_mp5_conditionzero\",\n        tag: \"Condition Zero\"\n    },\n    \"987\": {\n        name: \"cu_nova_polymer\",\n        tag: \"Clear Polymer\"\n    },\n    \"988\": {\n        name: \"cu_glock_noir\",\n        tag: \"Neo-Noir\"\n    },\n    \"989\": {\n        name: \"cu_ssg08_chromatic\",\n        tag: \"Parallax\"\n    },\n    \"990\": {\n        name: \"gs_ump_gold_bismuth\",\n        tag: \"Gold Bismuth\"\n    },\n    \"991\": {\n        name: \"cu_usp_krokos\",\n        tag: \"Monster Mashup\"\n    },\n    \"992\": {\n        name: \"am_numbers_bronze\",\n        tag: \"The Bronze\"\n    },\n    \"993\": {\n        name: \"cu_csgo_camo\",\n        tag: \"Global Offensive\"\n    },\n    \"994\": {\n        name: \"am_authority_brown\",\n        tag: \"Charter\"\n    },\n    \"995\": {\n        name: \"am_intelligence_grey\",\n        tag: \"Surveillance\"\n    },\n    \"996\": {\n        name: \"am_intelligence_orange\",\n        tag: \"Threat Detected\"\n    },\n    \"997\": {\n        name: \"am_numbers_red_blue\",\n        tag: \"Dispatch\"\n    },\n    \"998\": {\n        name: \"hy_numbers_green\",\n        tag: \"Switch Board\"\n    },\n    \"999\": {\n        name: \"am_numbers_magenta\",\n        tag: \"Prime Conspiracy\"\n    },\n    \"1000\": {\n        name: \"cu_jaguar_p90\",\n        tag: \"Run and Hide\"\n    },\n    \"1001\": {\n        name: \"cu_m4a1_snake\",\n        tag: \"Welcome to the Jungle\"\n    },\n    \"1002\": {\n        name: \"aa_fade_red_blue\",\n        tag: \"Berries And Cherries\"\n    },\n    \"1003\": {\n        name: \"cu_ump_crime_scene\",\n        tag: \"Crime Scene\"\n    },\n    \"1004\": {\n        name: \"cu_ak_xray\",\n        tag: \"X-Ray\"\n    },\n    \"1005\": {\n        name: \"am_heist_plans_green\",\n        tag: \"Heist\"\n    },\n    \"1006\": {\n        name: \"am_heist_plans_purple\",\n        tag: \"Night Heist\"\n    },\n    \"1007\": {\n        name: \"am_heist_plans_yellow\",\n        tag: \"Vault Heist\"\n    },\n    \"1008\": {\n        name: \"hy_houndstooth_brown\",\n        tag: \"Houndstooth\"\n    },\n    \"1009\": {\n        name: \"gs_mac10_snake\",\n        tag: \"Hot Snakes\"\n    },\n    \"1010\": {\n        name: \"hy_phoenix_tags_lilac\",\n        tag: \"Phoenix Chalk\"\n    },\n    \"1011\": {\n        name: \"am_phoenix_tags_blue\",\n        tag: \"Phoenix Marker\"\n    },\n    \"1012\": {\n        name: \"hy_phoenix_tags_red\",\n        tag: \"Phoenix Stencil\"\n    },\n    \"1013\": {\n        name: \"sp_phoenix_tags_purple\",\n        tag: \"Phoenix Blacklight\"\n    },\n    \"1014\": {\n        name: \"hy_tigers_tan\",\n        tag: \"Clay Ambush\"\n    },\n    \"1015\": {\n        name: \"am_tigers_brown\",\n        tag: \"Tiger Pit\"\n    },\n    \"1016\": {\n        name: \"cu_money_glock\",\n        tag: \"Franklin\"\n    },\n    \"1017\": {\n        name: \"am_m4a1s_bluesmoke\",\n        tag: \"Blue Phosphor\"\n    },\n    \"1018\": {\n        name: \"cu_ak_jaguar\",\n        tag: \"Panthera onca\"\n    },\n    \"1019\": {\n        name: \"am_black_panther\",\n        tag: \"Panther Camo\"\n    },\n    \"1020\": {\n        name: \"aa_ancient_brown\",\n        tag: \"Ancient Earth\"\n    },\n    \"1021\": {\n        name: \"am_ancient_warm\",\n        tag: \"Ancient Lore\"\n    },\n    \"1022\": {\n        name: \"aa_ruins_green\",\n        tag: \"Lush Ruins\"\n    },\n    \"1023\": {\n        name: \"hy_drywood_green\",\n        tag: \"Tall Grass\"\n    },\n    \"1024\": {\n        name: \"hy_ancient_tiles_peach\",\n        tag: \"Blast From the Past\"\n    },\n    \"1025\": {\n        name: \"am_gold_brick\",\n        tag: \"Gold Brick\"\n    },\n    \"1026\": {\n        name: \"aa_awp_fade\",\n        tag: \"Fade\"\n    },\n    \"1027\": {\n        name: \"am_intelligence_magenta\",\n        tag: \"Target Acquired\"\n    },\n    \"1028\": {\n        name: \"hy_authority_purple\",\n        tag: \"Magna Carta\"\n    },\n    \"1029\": {\n        name: \"am_tigers_blue\",\n        tag: \"Silk Tiger\"\n    },\n    \"1030\": {\n        name: \"hy_p250_tiger\",\n        tag: \"Bengal Tiger\"\n    },\n    \"1031\": {\n        name: \"sp_ancient_bright\",\n        tag: \"Ancient Visions\"\n    },\n    \"1032\": {\n        name: \"hy_ruins_red\",\n        tag: \"Dusk Ruins\"\n    },\n    \"1033\": {\n        name: \"am_jade\",\n        tag: \"Carved Jade\"\n    },\n    \"1034\": {\n        name: \"am_ancient_wine\",\n        tag: \"Ancient Ritual\"\n    },\n    \"1035\": {\n        name: \"gs_ak47_professional\",\n        tag: \"Slate\"\n    },\n    \"1036\": {\n        name: \"cu_cz75_whirlwind\",\n        tag: \"Circaetus\"\n    },\n    \"1037\": {\n        name: \"cu_mp9_food_chain\",\n        tag: \"Food Chain\"\n    },\n    \"1038\": {\n        name: \"cu_galil_chroma_pink\",\n        tag: \"Chromatic Aberration\"\n    },\n    \"1039\": {\n        name: \"gs_glock_polymer\",\n        tag: \"Clear Polymer\"\n    },\n    \"1040\": {\n        name: \"gs_usps_hangedman\",\n        tag: \"The Traitor\"\n    },\n    \"1041\": {\n        name: \"cu_m4a4_love\",\n        tag: \"In Living Color\"\n    },\n    \"1042\": {\n        name: \"gs_m249_combine\",\n        tag: \"O.S.I.P.R.\"\n    },\n    \"1043\": {\n        name: \"cu_negev_devtexture\",\n        tag: \"dev_texture\"\n    },\n    \"1044\": {\n        name: \"gs_p250_cybershell\",\n        tag: \"Cyber Shell\"\n    },\n    \"1045\": {\n        name: \"cu_mac10_portable\",\n        tag: \"Button Masher\"\n    },\n    \"1046\": {\n        name: \"aq_xm1014_punk\",\n        tag: \"XOXO\"\n    },\n    \"1047\": {\n        name: \"gs_r8_rustking\",\n        tag: \"Junk Yard\"\n    },\n    \"1048\": {\n        name: \"gs_sg553_deathmetal\",\n        tag: \"Heavy Metal\"\n    },\n    \"1049\": {\n        name: \"am_ump45_electrowave\",\n        tag: \"Oscillator\"\n    },\n    \"1050\": {\n        name: \"cu_deag_trigger_discipline\",\n        tag: \"Trigger Discipline\"\n    },\n    \"1051\": {\n        name: \"sp_nova_wind_dispersal\",\n        tag: \"Windblown\"\n    },\n    \"1052\": {\n        name: \"cu_ssg08_scorpion\",\n        tag: \"Death Strike\"\n    },\n    \"1053\": {\n        name: \"am_nuclear_pattern4_famas\",\n        tag: \"Meltdown\"\n    },\n    \"1055\": {\n        name: \"aa_spacerace_orange\",\n        tag: \"Space Race\"\n    },\n    \"1056\": {\n        name: \"sp_spacerace_blue\",\n        tag: \"Sputnik\"\n    },\n    \"1058\": {\n        name: \"hy_technowar_rwb\",\n        tag: \"POP AWP\"\n    },\n    \"1059\": {\n        name: \"sp_technowar_red\",\n        tag: \"Fizzy POP\"\n    },\n    \"1060\": {\n        name: \"hy_trainarchitect_green\",\n        tag: \"Spring Twilly\"\n    },\n    \"1061\": {\n        name: \"hy_trainarchitect\",\n        tag: \"Autumn Twilly\"\n    },\n    \"1063\": {\n        name: \"gs_m4a4_coalition\",\n        tag: \"The Coalition\"\n    },\n    \"1064\": {\n        name: \"gs_train_cz75\",\n        tag: \"Syndicate\"\n    },\n    \"1065\": {\n        name: \"so_whiteout_riptide\",\n        tag: \"Whiteout\"\n    },\n    \"1066\": {\n        name: \"aa_wiring_yellow\",\n        tag: \"Faulty Wiring\"\n    },\n    \"1067\": {\n        name: \"cu_mac10_propaganda\",\n        tag: \"Propaganda\"\n    },\n    \"1070\": {\n        name: \"hy_ak47lam_green\",\n        tag: \"Green Laminate\"\n    },\n    \"1071\": {\n        name: \"sp_galil_caution\",\n        tag: \"CAUTION!\"\n    },\n    \"1072\": {\n        name: \"hy_geometric_steps_pearl\",\n        tag: \"Prism Terrace\"\n    },\n    \"1073\": {\n        name: \"gs_m4a1_vertigo\",\n        tag: \"Imminent Danger\"\n    },\n    \"1074\": {\n        name: \"hy_vertigogeo\",\n        tag: \"Schematic\"\n    },\n    \"1075\": {\n        name: \"hy_vertigospray_blue\",\n        tag: \"Strats\"\n    },\n    \"1076\": {\n        name: \"hy_vertigoillusion\",\n        tag: \"Framework\"\n    },\n    \"1077\": {\n        name: \"hy_vertigoillusion_yellow\",\n        tag: \"Interlock\"\n    },\n    \"1078\": {\n        name: \"sp_tire_tread_blue\",\n        tag: \"Blue Tire\"\n    },\n    \"1079\": {\n        name: \"sp_tire_tread_red\",\n        tag: \"Red Tire\"\n    },\n    \"1080\": {\n        name: \"hy_vertigospray\",\n        tag: \"Infrastructure\"\n    },\n    \"1081\": {\n        name: \"aa_vertigogeo_neon\",\n        tag: \"Digital Architect\"\n    },\n    \"1082\": {\n        name: \"cu_vertigo_fiveseven\",\n        tag: \"Fall Hazard\"\n    },\n    \"1083\": {\n        name: \"aa_wiring\",\n        tag: \"Breaker Box\"\n    },\n    \"1084\": {\n        name: \"cu_sg553_caution\",\n        tag: \"Hazard Pay\"\n    },\n    \"1085\": {\n        name: \"aa_engine_performance\",\n        tag: \"Mechanism\"\n    },\n    \"1086\": {\n        name: \"sp_engine_dirty\",\n        tag: \"Oil Change\"\n    },\n    \"1087\": {\n        name: \"gs_ak47_abstract\",\n        tag: \"Leet Museo\"\n    },\n    \"1088\": {\n        name: \"gs_aug_plague\",\n        tag: \"Plague\"\n    },\n    \"1089\": {\n        name: \"gs_mag7_bismuth\",\n        tag: \"BI83 Spectrum\"\n    },\n    \"1090\": {\n        name: \"cu_deagle_kitch\",\n        tag: \"Ocean Drive\"\n    },\n    \"1091\": {\n        name: \"gs_dual_berettas_tread\",\n        tag: \"Tread\"\n    },\n    \"1092\": {\n        name: \"cu_famas_spectron\",\n        tag: \"ZX Spectron\"\n    },\n    \"1093\": {\n        name: \"gs_five_seven_efusion\",\n        tag: \"Boost Protocol\"\n    },\n    \"1094\": {\n        name: \"aa_mp9_fuji_pink\",\n        tag: \"Mount Fuji\"\n    },\n    \"1095\": {\n        name: \"cu_g3sg1_tacticalmap\",\n        tag: \"Keeping Tabs\"\n    },\n    \"1096\": {\n        name: \"cu_mp7_khaki\",\n        tag: \"Guerrilla\"\n    },\n    \"1097\": {\n        name: \"gs_m4_flowers\",\n        tag: \"Spider Lily\"\n    },\n    \"1098\": {\n        name: \"cu_mac10_toybox\",\n        tag: \"Toybox\"\n    },\n    \"1099\": {\n        name: \"gs_bizon_flasher\",\n        tag: \"Lumen\"\n    },\n    \"1100\": {\n        name: \"cu_glock_snackattack\",\n        tag: \"Snack Attack\"\n    },\n    \"1101\": {\n        name: \"cu_ssg_overtake\",\n        tag: \"Turbo Peek\"\n    },\n    \"1102\": {\n        name: \"cu_usp_black_lotus\",\n        tag: \"Black Lotus\"\n    },\n    \"1103\": {\n        name: \"gs_xm1014_watchdog\",\n        tag: \"Watchdog\"\n    },\n    \"1104\": {\n        name: \"cu_bowie_lore\",\n        tag: \"Lore\"\n    },\n    \"1105\": {\n        name: \"cu_butterfly_lore\",\n        tag: \"Lore\"\n    },\n    \"1106\": {\n        name: \"cu_falchion_lore\",\n        tag: \"Lore\"\n    },\n    \"1107\": {\n        name: \"cu_huntsman_lore\",\n        tag: \"Lore\"\n    },\n    \"1108\": {\n        name: \"cu_push_lore\",\n        tag: \"Lore\"\n    },\n    \"1109\": {\n        name: \"gs_bowie_black_laminate\",\n        tag: \"Black Laminate\"\n    },\n    \"1110\": {\n        name: \"gs_butterfly_black_laminate\",\n        tag: \"Black Laminate\"\n    },\n    \"1111\": {\n        name: \"gs_falchion_black_laminate\",\n        tag: \"Black Laminate\"\n    },\n    \"1112\": {\n        name: \"gs_huntsman_black_laminate\",\n        tag: \"Black Laminate\"\n    },\n    \"1113\": {\n        name: \"gs_push_black_laminate\",\n        tag: \"Black Laminate\"\n    },\n    \"1114\": {\n        name: \"gs_bowie_autotronic\",\n        tag: \"Autotronic\"\n    },\n    \"1115\": {\n        name: \"gs_butterfly_autotronic\",\n        tag: \"Autotronic\"\n    },\n    \"1116\": {\n        name: \"gs_falchion_autotronic\",\n        tag: \"Autotronic\"\n    },\n    \"1117\": {\n        name: \"gs_huntsman_autotronic\",\n        tag: \"Autotronic\"\n    },\n    \"1118\": {\n        name: \"gs_push_autotronic\",\n        tag: \"Autotronic\"\n    },\n    \"1119\": {\n        name: \"am_emerald_marbleized_glock\",\n        tag: \"Gamma Doppler\"\n    },\n    \"1120\": {\n        name: \"am_gamma_doppler_phase1_glock\",\n        tag: \"Gamma Doppler\"\n    },\n    \"1121\": {\n        name: \"am_gamma_doppler_phase2_glock\",\n        tag: \"Gamma Doppler\"\n    },\n    \"1122\": {\n        name: \"am_gamma_doppler_phase3_glock\",\n        tag: \"Gamma Doppler\"\n    },\n    \"1123\": {\n        name: \"am_gamma_doppler_phase4_glock\",\n        tag: \"Gamma Doppler\"\n    },\n    \"1125\": {\n        name: \"cu_bizon_spacecat\",\n        tag: \"Space Cat\"\n    },\n    \"1126\": {\n        name: \"cu_elites_beware\",\n        tag: \"Melondrama\"\n    },\n    \"1127\": {\n        name: \"gs_famas_rapid_eyes\",\n        tag: \"Rapid Eye Movement\"\n    },\n    \"1128\": {\n        name: \"cu_fiveseven_alpha_omega\",\n        tag: \"Scrawl\"\n    },\n    \"1129\": {\n        name: \"cu_g3sg1_glade\",\n        tag: \"Dream Glade\"\n    },\n    \"1130\": {\n        name: \"gs_m4a1s_insomnia\",\n        tag: \"Night Terror\"\n    },\n    \"1131\": {\n        name: \"cu_mac10_pixie\",\n        tag: \"Ensnared\"\n    },\n    \"1132\": {\n        name: \"cu_mag7_predictor\",\n        tag: \"Foresight\"\n    },\n    \"1133\": {\n        name: \"cu_mp7_fear\",\n        tag: \"Abyssal Apparition\"\n    },\n    \"1134\": {\n        name: \"gs_mp9_starlight\",\n        tag: \"Starlight Protector\"\n    },\n    \"1135\": {\n        name: \"am_xm_zombie_offensive\",\n        tag: \"Zombie Offensive\"\n    },\n    \"1136\": {\n        name: \"cu_usp_to_hell\",\n        tag: \"Ticket to Hell\"\n    },\n    \"1137\": {\n        name: \"gs_mp5_kid_necronomicon\",\n        tag: \"Necro Jr.\"\n    },\n    \"1138\": {\n        name: \"cu_p2k_flying_dream\",\n        tag: \"Lifted Spirits\"\n    },\n    \"1139\": {\n        name: \"sp_scar_chickenfight\",\n        tag: \"Poultrygeist\"\n    },\n    \"1140\": {\n        name: \"cu_sawedoff_ouija\",\n        tag: \"Spirit Board\"\n    },\n    \"1141\": {\n        name: \"cu_ak47_nightwish\",\n        tag: \"Nightwish\"\n    },\n    \"1142\": {\n        name: \"cu_usp_printstream\",\n        tag: \"Printstream\"\n    },\n    \"1143\": {\n        name: \"cu_ak47_cogthings\",\n        tag: \"Ice Coaled\"\n    },\n    \"1144\": {\n        name: \"cu_awp_chroma_pink\",\n        tag: \"Chromatic Aberration\"\n    },\n    \"1145\": {\n        name: \"gs_revolver_purple_elite\",\n        tag: \"Crazy 8\"\n    },\n    \"1146\": {\n        name: \"gs_famas_corp_meow\",\n        tag: \"Meow 36\"\n    },\n    \"1147\": {\n        name: \"cu_galil_destroyer\",\n        tag: \"Destroyer\"\n    },\n    \"1148\": {\n        name: \"cu_m249_downvote\",\n        tag: \"Downtown\"\n    },\n    \"1149\": {\n        name: \"cu_m4a4_elite_tactical\",\n        tag: \"Poly Mag\"\n    },\n    \"1150\": {\n        name: \"cu_mac10_monkeyflage\",\n        tag: \"Monkeyflage\"\n    },\n    \"1151\": {\n        name: \"cu_sg553_cyber_dragon\",\n        tag: \"Dragon Tech\"\n    },\n    \"1152\": {\n        name: \"cu_negev_clear_sky\",\n        tag: \"Drop Me\"\n    },\n    \"1153\": {\n        name: \"gs_p250_visions\",\n        tag: \"Visions\"\n    },\n    \"1154\": {\n        name: \"gs_p90_tangled\",\n        tag: \"Vent Rush\"\n    },\n    \"1155\": {\n        name: \"cu_sawedoff_kisslove\",\n        tag: \"Kiss♥Love\"\n    },\n    \"1156\": {\n        name: \"cu_dual_elites_evil_flora\",\n        tag: \"Flora Carnivora\"\n    },\n    \"1157\": {\n        name: \"gs_ump_roadblock\",\n        tag: \"Roadblock\"\n    },\n    \"1158\": {\n        name: \"gs_glock_elite_camo\",\n        tag: \"Winterized\"\n    },\n    \"10006\": {\n        name: \"bloodhound_black_silver\",\n        tag: \"Charred\"\n    },\n    \"10007\": {\n        name: \"bloodhound_snakeskin_brass\",\n        tag: \"Snakebite\"\n    },\n    \"10008\": {\n        name: \"bloodhound_metallic\",\n        tag: \"Bronzed\"\n    },\n    \"10009\": {\n        name: \"handwrap_leathery\",\n        tag: \"Leather\"\n    },\n    \"10010\": {\n        name: \"handwrap_camo_grey\",\n        tag: \"Spruce DDPAT\"\n    },\n    \"10013\": {\n        name: \"slick_black\",\n        tag: \"Lunar Weave\"\n    },\n    \"10015\": {\n        name: \"slick_military\",\n        tag: \"Convoy\"\n    },\n    \"10016\": {\n        name: \"slick_red\",\n        tag: \"Crimson Weave\"\n    },\n    \"10018\": {\n        name: \"sporty_light_blue\",\n        tag: \"Superconductor\"\n    },\n    \"10019\": {\n        name: \"sporty_military\",\n        tag: \"Arid\"\n    },\n    \"10021\": {\n        name: \"handwrap_red_slaughter\",\n        tag: \"Slaughter\"\n    },\n    \"10024\": {\n        name: \"motorcycle_basic_black\",\n        tag: \"Eclipse\"\n    },\n    \"10026\": {\n        name: \"motorcycle_mint_triangle\",\n        tag: \"Spearmint\"\n    },\n    \"10027\": {\n        name: \"motorcycle_mono_boom\",\n        tag: \"Boom!\"\n    },\n    \"10028\": {\n        name: \"motorcycle_triangle_blue\",\n        tag: \"Cool Mint\"\n    },\n    \"10030\": {\n        name: \"specialist_ddpat_green_camo\",\n        tag: \"Forest DDPAT\"\n    },\n    \"10033\": {\n        name: \"specialist_kimono_diamonds_red\",\n        tag: \"Crimson Kimono\"\n    },\n    \"10034\": {\n        name: \"specialist_emerald_web\",\n        tag: \"Emerald Web\"\n    },\n    \"10035\": {\n        name: \"specialist_orange_white\",\n        tag: \"Foundation\"\n    },\n    \"10036\": {\n        name: \"handwrap_fabric_orange_camo\",\n        tag: \"Badlands\"\n    },\n    \"10037\": {\n        name: \"sporty_purple\",\n        tag: \"Pandora's Box\"\n    },\n    \"10038\": {\n        name: \"sporty_green\",\n        tag: \"Hedge Maze\"\n    },\n    \"10039\": {\n        name: \"bloodhound_guerrilla\",\n        tag: \"Guerrilla\"\n    },\n    \"10040\": {\n        name: \"slick_snakeskin_yellow\",\n        tag: \"Diamondback\"\n    },\n    \"10041\": {\n        name: \"slick_snakeskin_white\",\n        tag: \"King Snake\"\n    },\n    \"10042\": {\n        name: \"slick_plaid_purple\",\n        tag: \"Imperial Plaid\"\n    },\n    \"10043\": {\n        name: \"slick_stitched_black_orange\",\n        tag: \"Overtake\"\n    },\n    \"10044\": {\n        name: \"slick_stitched_green_grey\",\n        tag: \"Racing Green\"\n    },\n    \"10045\": {\n        name: \"sporty_poison_frog_blue_white\",\n        tag: \"Amphibious\"\n    },\n    \"10046\": {\n        name: \"sporty_poison_frog_red_green\",\n        tag: \"Bronze Morph\"\n    },\n    \"10047\": {\n        name: \"sporty_black_webbing_yellow\",\n        tag: \"Omega\"\n    },\n    \"10048\": {\n        name: \"sporty_blue_pink\",\n        tag: \"Vice\"\n    },\n    \"10049\": {\n        name: \"motorcycle_choco_boom\",\n        tag: \"POW!\"\n    },\n    \"10050\": {\n        name: \"motorcycle_basic_green_orange\",\n        tag: \"Turtle\"\n    },\n    \"10051\": {\n        name: \"motorcycle_yellow_camo\",\n        tag: \"Transport\"\n    },\n    \"10052\": {\n        name: \"motorcycle_trigrid_blue\",\n        tag: \"Polygon\"\n    },\n    \"10053\": {\n        name: \"handwrap_leathery_fabric_blue_skulls\",\n        tag: \"Cobalt Skulls\"\n    },\n    \"10054\": {\n        name: \"handwrap_leathery_fabric_geometric_blue\",\n        tag: \"Overprint\"\n    },\n    \"10055\": {\n        name: \"handwrap_leathery_ducttape\",\n        tag: \"Duct Tape\"\n    },\n    \"10056\": {\n        name: \"handwrap_leathery_fabric_green_camo\",\n        tag: \"Arboreal\"\n    },\n    \"10057\": {\n        name: \"bloodhound_hydra_black_green\",\n        tag: \"Emerald\"\n    },\n    \"10058\": {\n        name: \"bloodhound_hydra_green_leather_mesh_brass\",\n        tag: \"Mangrove\"\n    },\n    \"10059\": {\n        name: \"bloodhound_hydra_snakeskin_brass\",\n        tag: \"Rattler\"\n    },\n    \"10060\": {\n        name: \"bloodhound_hydra_case_hardened\",\n        tag: \"Case Hardened\"\n    },\n    \"10061\": {\n        name: \"specialist_webs_red\",\n        tag: \"Crimson Web\"\n    },\n    \"10062\": {\n        name: \"specialist_forest_brown\",\n        tag: \"Buckshot\"\n    },\n    \"10063\": {\n        name: \"specialist_fade\",\n        tag: \"Fade\"\n    },\n    \"10064\": {\n        name: \"specialist_winterhex\",\n        tag: \"Mogul\"\n    },\n    \"10065\": {\n        name: \"specialist_marble_fade\",\n        tag: \"Marble Fade\"\n    },\n    \"10066\": {\n        name: \"specialist_ricksaw_camo\",\n        tag: \"Lt. Commander\"\n    },\n    \"10067\": {\n        name: \"specialist_tiger_orange\",\n        tag: \"Tiger Strike\"\n    },\n    \"10068\": {\n        name: \"specialist_fbi\",\n        tag: \"Field Agent\"\n    },\n    \"10069\": {\n        name: \"slick_rezan\",\n        tag: \"Rezan the Red\"\n    },\n    \"10070\": {\n        name: \"slick_jaguar_white\",\n        tag: \"Snow Leopard\"\n    },\n    \"10071\": {\n        name: \"slick_jaguar_yellow\",\n        tag: \"Queen Jaguar\"\n    },\n    \"10072\": {\n        name: \"slick_stitched_black_white\",\n        tag: \"Black Tie\"\n    },\n    \"10073\": {\n        name: \"sporty_slingshot\",\n        tag: \"Slingshot\"\n    },\n    \"10074\": {\n        name: \"sporty_hunter\",\n        tag: \"Big Game\"\n    },\n    \"10075\": {\n        name: \"sporty_houndstooth_red\",\n        tag: \"Scarlet Shamagh\"\n    },\n    \"10076\": {\n        name: \"sporty_jaguar\",\n        tag: \"Nocts\"\n    },\n    \"10077\": {\n        name: \"motorcycle_checker_flag_blue_green\",\n        tag: \"Finish Line\"\n    },\n    \"10078\": {\n        name: \"motorcycle_smoke\",\n        tag: \"Smoke Out\"\n    },\n    \"10079\": {\n        name: \"motorcycle_carbonfiber_red\",\n        tag: \"Blood Pressure\"\n    },\n    \"10080\": {\n        name: \"motorcycle_commando_ksk\",\n        tag: \"3rd Commando Company\"\n    },\n    \"10081\": {\n        name: \"handwrap_fabric_houndstooth_orange\",\n        tag: \"Desert Shamagh\"\n    },\n    \"10082\": {\n        name: \"handwrap_leathery_fabric_giraffe\",\n        tag: \"Giraffe\"\n    },\n    \"10083\": {\n        name: \"handwrap_leathery_snakeskin_orange\",\n        tag: \"Constrictor\"\n    },\n    \"10084\": {\n        name: \"handwrap_leathery_caution\",\n        tag: \"CAUTION!\"\n    },\n    \"10085\": {\n        name: \"operation10_metalic_green\",\n        tag: \"Jade\"\n    },\n    \"10086\": {\n        name: \"operation10_poison_frog_black_yellow\",\n        tag: \"Yellow-banded\"\n    },\n    \"10087\": {\n        name: \"operation10_floral\",\n        tag: \"Needle Point\"\n    },\n    \"10088\": {\n        name: \"operation10_snakeskin_black\",\n        tag: \"Unhinged\"\n    }\n};\n//# sourceMappingURL=itemdefs.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Networkable = void 0;\nconst consts_1 = require(\"../consts\");\n/**\n * Represents an in-game entity.\n */\nclass Networkable {\n    constructor(demo, index, classId, serialNum, props) {\n        /**\n         * Entity is scheduled for removal this tick.\n         */\n        this.deleting = false;\n        this._demo = demo;\n        this.index = index;\n        this.classId = classId;\n        this.serialNum = serialNum;\n        this.props = props || {};\n    }\n    /**\n     * Get the serverclass associated with this entity.\n     * @returns Object representing the entity's class\n     */\n    get serverClass() {\n        return this._demo.entities.serverClasses[this.classId];\n    }\n    /**\n     * @returns Number uniquely identifying this entity. Should be unique throughout the entire demo.\n     */\n    get handle() {\n        return this.index | (this.serialNum << consts_1.MAX_EDICT_BITS);\n    }\n    /**\n     * Retrieves the value of a networked property\n     * @param {string} tableName - Table name (e.g., DT_BaseEntity)\n     * @param {string} varName - Network variable name (e.g., m_vecOrigin)\n     * @returns {*} Property value, `undefined` if non-existent\n     * @public\n     */\n    getProp(tableName, varName) {\n        return this.props[tableName][varName];\n    }\n    /**\n     * Interpret an array-like data table (e.g., m_iAmmo) as an array\n     * @param tableName Name of the data table\n     */\n    getIndexedProps(tableName) {\n        if (!(\"000\" in this.props[tableName])) {\n            return undefined;\n        }\n        return Object.values(this.props[tableName]);\n    }\n    /**\n     * Update the value of a prop\n     * @param tableName Name of the data table\n     * @param varName Name of the prop to update\n     * @param newValue New prop value\n     */\n    updateProp(tableName, varName, newValue) {\n        const table = this.props[tableName];\n        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n        if (table === undefined) {\n            this.props[tableName] = {\n                [varName]: newValue\n            };\n        }\n        else {\n            table[varName] = newValue;\n        }\n    }\n    /**\n     * True if this entity is out of the PVS.\n     * Always false on GOTV demos as all entities are always in the PVS.\n     */\n    get isDormant() {\n        return !this._demo.entities.transmitEntities.has(this.index);\n    }\n    toJSON() {\n        return `#${this.index}(${this.serverClass.name})`;\n    }\n}\nexports.Networkable = Networkable;\n//# sourceMappingURL=networkable.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Player = void 0;\nconst crosshair_1 = require(\"../crosshair\");\nconst baseentity_1 = require(\"./baseentity\");\nconst weapon_1 = require(\"./weapon\");\n/**\n * Represents an in-game player.\n */\nclass Player extends baseentity_1.BaseEntity {\n    constructor(demo, index, classId, serialNum, baseline) {\n        super(demo, index, classId, serialNum, baseline);\n        /**\n         * The 'client slot' is the index into various arrays such as the userinfo table.\n         */\n        this.clientSlot = index - 1;\n    }\n    /**\n     * @returns {int} Current health\n     */\n    get health() {\n        return this.getProp(\"DT_BasePlayer\", \"m_iHealth\");\n    }\n    get eyeAngles() {\n        return {\n            pitch: this.getProp(\"DT_CSPlayer\", \"m_angEyeAngles[0]\"),\n            yaw: this.getProp(\"DT_CSPlayer\", \"m_angEyeAngles[1]\")\n        };\n    }\n    get position() {\n        const table = this._demo.recordingClientSlot == null || this.isRecordingDemo\n            ? \"DT_CSLocalPlayerExclusive\"\n            : \"DT_CSNonLocalPlayerExclusive\";\n        const xy = this.getProp(table, \"m_vecOrigin\");\n        return {\n            x: xy.x,\n            y: xy.y,\n            z: this.getProp(table, \"m_vecOrigin[2]\")\n        };\n    }\n    get velocity() {\n        return this._demo.recordingClientSlot == null || this.isRecordingDemo\n            ? {\n                x: this.getProp(\"DT_LocalPlayerExclusive\", \"m_vecVelocity[0]\"),\n                y: this.getProp(\"DT_LocalPlayerExclusive\", \"m_vecVelocity[1]\"),\n                z: this.getProp(\"DT_LocalPlayerExclusive\", \"m_vecVelocity[2]\")\n            }\n            : { x: 0, y: 0, z: 0 };\n    }\n    /**\n     * Speed of the entity.\n     * @returns Speed in game units.\n     */\n    get speed() {\n        const vel = this.velocity;\n        return Math.sqrt(vel.x * vel.x + vel.y * vel.y + vel.z * vel.z);\n    }\n    /**\n     * @returns Current cash\n     */\n    get account() {\n        return this.getProp(\"DT_CSPlayer\", \"m_iAccount\");\n    }\n    get lifeState() {\n        return this.getProp(\"DT_BasePlayer\", \"m_lifeState\");\n    }\n    /**\n     * @returns lifeState == 0\n     */\n    get isAlive() {\n        return this.lifeState === 0 /* LifeState.Alive */;\n    }\n    /**\n     * @returns User info associated with this player\n     */\n    get userInfo() {\n        return this._demo.entities._userInfoTable.entries[this.clientSlot]\n            .userData;\n    }\n    /**\n     * @returns User ID\n     */\n    get userId() {\n        return this.userInfo.userId;\n    }\n    /**\n     * @returns Steam ID\n     */\n    get steamId() {\n        return this.userInfo.guid;\n    }\n    /**\n     * @returns Steam 64 ID\n     */\n    get steam64Id() {\n        if (this._steam64IdCache === undefined)\n            this._steam64IdCache = this.userInfo.xuid.toString();\n        return this._steam64IdCache;\n    }\n    /**\n     * @returns Player name\n     */\n    get name() {\n        return this.userInfo.name;\n    }\n    /**\n     * @returns Is this player fake (i.e. a bot)\n     */\n    get isFakePlayer() {\n        return this.userInfo.fakePlayer;\n    }\n    /**\n     * @returns Is this player a HLTV relay\n     */\n    get isHltv() {\n        return this.userInfo.isHltv;\n    }\n    /**\n     * @returns Player armor (0-100)\n     */\n    get armor() {\n        return this.getProp(\"DT_CSPlayer\", \"m_ArmorValue\");\n    }\n    /**\n     * @returns Current navmesh place name\n     */\n    get placeName() {\n        return this.getProp(\"DT_BasePlayer\", \"m_szLastPlaceName\");\n    }\n    /**\n     * @returns Currently held weapon\n     */\n    get weapon() {\n        return this._demo.entities.getByHandle(this.getProp(\"DT_BaseCombatCharacter\", \"m_hActiveWeapon\"));\n    }\n    /**\n     * @returns All weapons helds by this player\n     */\n    get weapons() {\n        return this.getIndexedProps(\"m_hMyWeapons\")\n            .map(handle => this._demo.entities.getByHandle(handle))\n            .filter(ent => ent ? ent instanceof weapon_1.Weapon : false);\n    }\n    /**\n     * @returns Is the player is the bomb zone?\n     */\n    get isInBombZone() {\n        return this.getProp(\"DT_CSPlayer\", \"m_bInBombZone\");\n    }\n    /**\n     * @returns Is the player in the buy zone?\n     */\n    get isInBuyZone() {\n        return this.getProp(\"DT_CSPlayer\", \"m_bInBuyZone\");\n    }\n    /**\n     * @returns Is the player defusing?\n     */\n    get isDefusing() {\n        return this.getProp(\"DT_CSPlayer\", \"m_bIsDefusing\");\n    }\n    /**\n     * @returns Does the player have a defuser?\n     */\n    get hasDefuser() {\n        return this.getProp(\"DT_CSPlayer\", \"m_bHasDefuser\");\n    }\n    /**\n     * @returns Does the player have a helmet?\n     */\n    get hasHelmet() {\n        return this.getProp(\"DT_CSPlayer\", \"m_bHasHelmet\");\n    }\n    /**\n     * @returns Does the player is controlling a BOT?\n     */\n    get isControllingBot() {\n        return this.getProp(\"DT_CSPlayer\", \"m_bIsControllingBot\");\n    }\n    /**\n     * Retrieves the value of an array property on the singleton entity DT_CSPlayerResource.\n     * @param {string} propName - Name of the property on DT_CSPlayerResource to retrieve\n     * @returns {*} Property value\n     */\n    resourceProp(tableName) {\n        const array = this._demo.entities.playerResource.getIndexedProps(tableName);\n        return array[this.index];\n    }\n    /**\n     * @returns How many kills the player has made\n     */\n    get kills() {\n        return this.resourceProp(\"m_iKills\");\n    }\n    /**\n     * @returns How many assists the player has made\n     */\n    get assists() {\n        return this.resourceProp(\"m_iAssists\");\n    }\n    /**\n     * @returns How many times the player has died\n     */\n    get deaths() {\n        return this.resourceProp(\"m_iDeaths\");\n    }\n    /**\n     * @returns Cash that this player has spent this round\n     */\n    get cashSpendThisRound() {\n        return this.resourceProp(\"m_iCashSpentThisRound\");\n    }\n    /**\n     * @returns Cash that the player has spent all game\n     */\n    get cashSpendTotal() {\n        return this.resourceProp(\"m_iTotalCashSpent\");\n    }\n    /**\n     * @returns Whether the player holds the C4\n     */\n    get hasC4() {\n        const pr = this._demo.entities.playerResource;\n        return pr.getProp(\"DT_CSPlayerResource\", \"m_iPlayerC4\") === this.index;\n    }\n    /**\n     * @returns Score of the player\n     */\n    get score() {\n        const pr = this._demo.entities.playerResource;\n        return pr.getIndexedProps(\"m_iScore\")[this.index];\n    }\n    /**\n     * @returns MVPs of the player\n     */\n    get mvps() {\n        const pr = this._demo.entities.playerResource;\n        return pr.getIndexedProps(\"m_iMVPs\")[this.index];\n    }\n    /**\n     * @returns Clantag of the player\n     */\n    get clanTag() {\n        const pr = this._demo.entities.playerResource;\n        return pr.getIndexedProps(\"m_szClan\")[this.index];\n    }\n    /**\n     * @returns Has this player been spotted by any others?\n     */\n    get isSpotted() {\n        return this.getProp(\"DT_BaseEntity\", \"m_bSpotted\");\n    }\n    /**\n     * Checks if this player has been spotted by the other.\n     * Note that this still returns true if spotted by the other player even if\n     * the other player is dead.\n     * @param other - Other player entity\n     * @returns Is this player spotted by the other?\n     */\n    isSpottedBy(other) {\n        let bit = other.clientSlot;\n        let mask = null;\n        if (other.clientSlot < 32) {\n            mask = this.getProp(\"m_bSpottedByMask\", \"000\");\n        }\n        else {\n            bit = other.clientSlot - 32;\n            mask = this.getProp(\"m_bSpottedByMask\", \"001\");\n        }\n        return (mask & (1 << bit)) !== 0;\n    }\n    /**\n     * @returns Alive players that have spotted this player\n     */\n    get allSpotters() {\n        return this._demo.players.filter(p => p.clientSlot !== this.clientSlot && p.isAlive && this.isSpottedBy(p));\n    }\n    /**\n     * Checks if this player has spotted another.\n     * Can still return true even if this player is dead.\n     * @param other - Other player entity\n     * @returns Has this player spotted the other?\n     */\n    hasSpotted(other) {\n        return other.isSpottedBy(this);\n    }\n    /**\n     * @returns Alive players that this player has spotted\n     */\n    get allSpotted() {\n        return this._demo.players.filter(p => p.clientSlot !== this.clientSlot && p.isAlive && this.hasSpotted(p));\n    }\n    /**\n     * @param other - Other player entity\n     * @returns Whether the two players are on the same team\n     */\n    isFriendly(other) {\n        const sameTeam = this.teamNumber === other.teamNumber;\n        const teammatesAreEnemies = this._demo.conVars.vars.get(\"mp_teammates_are_enemies\") || 0;\n        return sameTeam && !teammatesAreEnemies;\n    }\n    /**\n     * @returns Is scoped\n     */\n    get isScoped() {\n        return this.getProp(\"DT_CSPlayer\", \"m_bIsScoped\");\n    }\n    /**\n     * @returns Is walking\n     */\n    get isWalking() {\n        return this.getProp(\"DT_CSPlayer\", \"m_bIsWalking\");\n    }\n    /**\n     * @returns Player is transitioning from ducked -> standing or standing -> ducked\n     */\n    get isDucking() {\n        return this.getProp(\"DT_Local\", \"m_bDucking\");\n    }\n    /**\n     * @returns Is ducked\n     */\n    get isDucked() {\n        return this.getProp(\"DT_Local\", \"m_bDucked\");\n    }\n    /**\n     * @returns Duration of a flash that hit the player\n     */\n    get flashDuration() {\n        return this.getProp(\"DT_CSPlayer\", \"m_flFlashDuration\");\n    }\n    /**\n     * @returns Current equipment value\n     */\n    get currentEquipmentValue() {\n        return this.getProp(\"DT_CSPlayer\", \"m_unCurrentEquipmentValue\");\n    }\n    /**\n     * @returns Round start equipment value\n     */\n    get roundStartEquipmentValue() {\n        return this.getProp(\"DT_CSPlayer\", \"m_unRoundStartEquipmentValue\");\n    }\n    /**\n     * @returns Freeze time end equipment value\n     */\n    get freezeTimeEndEquipmentValue() {\n        return this.getProp(\"DT_CSPlayer\", \"m_unFreezetimeEndEquipmentValue\");\n    }\n    /**\n     * @returns Object representing the player's performance per round\n     */\n    get matchStats() {\n        const kills = this.getIndexedProps(\"m_iMatchStats_Kills\");\n        const damage = this.getIndexedProps(\"m_iMatchStats_Damage\");\n        const equipmentValue = this.getIndexedProps(\"m_iMatchStats_EquipmentValue\");\n        const moneySaved = this.getIndexedProps(\"m_iMatchStats_MoneySaved\");\n        const killReward = this.getIndexedProps(\"m_iMatchStats_KillReward\");\n        const liveTime = this.getIndexedProps(\"m_iMatchStats_LiveTime\");\n        const deaths = this.getIndexedProps(\"m_iMatchStats_Deaths\");\n        const assists = this.getIndexedProps(\"m_iMatchStats_Assists\");\n        const headShotKills = this.getIndexedProps(\"m_iMatchStats_HeadShotKills\");\n        const objective = this.getIndexedProps(\"m_iMatchStats_Objective\");\n        const rounds = new Array();\n        for (let roundIdx = 0; roundIdx < kills.length; ++roundIdx) {\n            rounds.push({\n                kills: kills[roundIdx],\n                damage: damage[roundIdx],\n                equipmentValue: equipmentValue[roundIdx],\n                moneySaved: moneySaved[roundIdx],\n                killReward: killReward[roundIdx],\n                liveTime: liveTime[roundIdx],\n                deaths: deaths[roundIdx],\n                assists: assists[roundIdx],\n                headShotKills: headShotKills[roundIdx],\n                objective: objective[roundIdx]\n            });\n        }\n        return rounds;\n    }\n    /**\n     * @returns Object representing user-customisable crosshair settings.\n     */\n    get crosshairInfo() {\n        return (0, crosshair_1.decodeCrosshairCode)(this.resourceProp(\"m_szCrosshairCodes\"));\n    }\n    /**\n     * @returns true if this player is recording the demo from their POV.\n     */\n    get isRecordingDemo() {\n        return this._demo.recordingClientSlot === this.clientSlot;\n    }\n}\nexports.Player = Player;\n//# sourceMappingURL=player.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Projectile = void 0;\nconst baseentity_1 = require(\"./baseentity\");\n/**\n * Represents a grenade projectile.\n */\nclass Projectile extends baseentity_1.BaseEntity {\n    /**\n     * @returns {GrenadeType} Type of grenade that this projectile is.\n     */\n    get grenadeType() {\n        switch (this.modelName) {\n            case \"models/Weapons/w_eq_fraggrenade_dropped.mdl\":\n                return \"explosive\";\n            case \"models/Weapons/w_eq_flashbang_dropped.mdl\":\n                return \"flashbang\";\n            case \"models/Weapons/w_eq_molotov_dropped.mdl\":\n                return \"molotov\";\n            case \"models/Weapons/w_eq_incendiarygrenade_dropped.mdl\":\n                return \"incendiary\";\n            case \"models/Weapons/w_eq_decoy_dropped.mdl\":\n                return \"decoy\";\n            case \"models/Weapons/w_eq_smokegrenade_thrown.mdl\":\n                return \"smoke\";\n            default:\n                throw new Error(`Unknown projectile with model: ${this.modelName}`);\n        }\n    }\n}\nexports.Projectile = Projectile;\n//# sourceMappingURL=projectile.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Team = void 0;\nconst networkable_1 = require(\"./networkable\");\nconst player_1 = require(\"./player\");\n/**\n * Represents an in-game team.\n */\nclass Team extends networkable_1.Networkable {\n    /**\n     * @returns {Player[]} All players in this team\n     */\n    get members() {\n        // UNSAFE: cast here as members will always be players\n        return this.getProp(\"DT_Team\", '\"player_array\"')\n            .map(index => this._demo.entities.entities.get(index))\n            .filter(player => player instanceof player_1.Player);\n    }\n    /**\n     * @returns {int} 0: Unassigned, 1: Spectator, 2: Terrorist, 3: Counter-Terrorist\n     */\n    get teamNumber() {\n        return this.getProp(\"DT_Team\", \"m_iTeamNum\");\n    }\n    /**\n     * @returns Clan name\n     */\n    get clanName() {\n        return this.getProp(\"DT_Team\", \"m_szClanTeamname\");\n    }\n    /**\n     * @returns 'SPECTATOR', 'TERRORIST' or 'COUNTERTERRORIST'\n     */\n    get teamName() {\n        return this.getProp(\"DT_Team\", \"m_szTeamname\");\n    }\n    /**\n     * @returns Total score\n     */\n    get score() {\n        return this.getProp(\"DT_Team\", \"m_scoreTotal\");\n    }\n    /**\n     * @returns First half score\n     */\n    get scoreFirstHalf() {\n        return this.getProp(\"DT_Team\", \"m_scoreFirstHalf\");\n    }\n    /**\n     * @returns Second half score\n     */\n    get scoreSecondHalf() {\n        return this.getProp(\"DT_Team\", \"m_scoreSecondHalf\");\n    }\n    /**\n     * @returns Team flag image\n     */\n    get flagImage() {\n        return this.getProp(\"DT_Team\", \"m_szTeamFlagImage\");\n    }\n    /**\n     * @returns Team logo image\n     */\n    get logoImage() {\n        return this.getProp(\"DT_Team\", \"m_szTeamLogoImage\");\n    }\n}\nexports.Team = Team;\n//# sourceMappingURL=team.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Weapon = void 0;\nconst baseentity_1 = require(\"./baseentity\");\nconst itemdefs_1 = require(\"./itemdefs\");\nconst qualities = [\n    \"normal\",\n    \"genuine\",\n    \"vintage\",\n    \"unusual\",\n    \"unique\",\n    \"community\",\n    \"developer\",\n    \"selfmade\",\n    \"customized\",\n    \"strange\",\n    \"completed\",\n    \"haunted\",\n    \"tournament\",\n    \"favored\"\n];\n/**\n * Represents an in-game weapon (guns, grenades, knifes).\n */\nclass Weapon extends baseentity_1.BaseEntity {\n    /**\n     * @returns Owning player, if any\n     */\n    get owner() {\n        return super.owner;\n    }\n    /**\n     * @returns Item definition index\n     */\n    get itemIndex() {\n        return this.getProp(\"DT_ScriptCreatedItem\", \"m_iItemDefinitionIndex\");\n    }\n    /**\n     * @returns Name of the weapon (e.g. \"Five-SeveN\")\n     */\n    get itemName() {\n        const weaponId = this.itemIndex;\n        const itemDefinition = itemdefs_1.itemDefinitionIndexMap[weaponId];\n        return itemDefinition !== undefined ? itemDefinition.itemName : null;\n    }\n    /**\n     * @returns Entity class name of the weapon (e.g. \"weapon_ak47\")\n     */\n    get className() {\n        const weaponId = this.itemIndex;\n        const itemDefinition = itemdefs_1.itemDefinitionIndexMap[weaponId];\n        return itemDefinition !== undefined ? itemDefinition.className : null;\n    }\n    /**\n     * @returns Previous owner\n     */\n    get prevOwner() {\n        const handle = this.getProp(\"DT_WeaponCSBase\", \"m_hPrevOwner\");\n        return this._demo.entities.getByHandle(handle);\n    }\n    /**\n     * @returns Amount of ammo in the clip of the weapon\n     */\n    get clipAmmo() {\n        return this.getProp(\"DT_BaseCombatWeapon\", \"m_iClip1\");\n    }\n    /**\n     * @returns The amount ammo this weapon has in reserve\n     */\n    get reserveAmmo() {\n        return this.getProp(\"DT_BaseCombatWeapon\", \"m_iPrimaryReserveAmmoCount\");\n    }\n    /**\n     * @returns The amount of ammo the owner holds for this weapon. Null if no owner.\n     */\n    get ownerAmmo() {\n        if (!this.owner)\n            return null;\n        const ammoType = this.getProp(\"DT_LocalWeaponData\", \"m_iPrimaryAmmoType\");\n        if (ammoType === -1)\n            return null;\n        return this.owner.getIndexedProps(\"m_iAmmo\")[ammoType];\n    }\n    /**\n     * @returns Quality of the item.\n     */\n    get quality() {\n        const quality = this.getProp(\"DT_ScriptCreatedItem\", \"m_iEntityQuality\");\n        return qualities[quality];\n    }\n}\nexports.Weapon = Weapon;\n//# sourceMappingURL=weapon.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.EntityHandle = void 0;\nconst consts_1 = require(\"./consts\");\nclass EntityHandle {\n    constructor(value) {\n        this.value = value;\n    }\n    get isValid() {\n        return this.value !== consts_1.INVALID_NETWORKED_EHANDLE_VALUE;\n    }\n    get index() {\n        return this.value & consts_1.NETWORKED_EHANDLE_ENT_ENTRY_MASK;\n    }\n    get serialNum() {\n        return this.value >> consts_1.MAX_EDICT_BITS;\n    }\n}\nexports.EntityHandle = EntityHandle;\n//# sourceMappingURL=entityhandle.js.map","\"use strict\";\n/* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument, sonarjs/no-duplicated-branches */\n// DO NOT MODIFY!\n// Auto-generated by ./generators/eventtypes.ts\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.annotateEvent = void 0;\nconst itemdefs_1 = require(\"./entities/itemdefs\");\nconst Long = require(\"long\");\nfunction annotateEvent(entities, eventName, event) {\n    if (eventName === \"bomb_begindefuse\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"bomb_beginplant\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"bomb_defused\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"bomb_dropped\") {\n        event.player = entities.getByUserId(event.userid);\n        event.entity = entities.entities.get(event.entindex);\n    }\n    else if (eventName === \"bomb_exploded\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"bomb_pickup\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"bomb_planted\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"bot_takeover\") {\n        event.player = entities.getByUserId(event.userid);\n        event.bot = entities.getByUserId(event.botid);\n    }\n    else if (eventName === \"cs_win_panel_round\") {\n        event.player = entities.entities.get(event.funfact_player);\n    }\n    else if (eventName === \"decoy_detonate\") {\n        event.player = entities.getByUserId(event.userid);\n        event.entity = entities.entities.get(event.entityid);\n    }\n    else if (eventName === \"decoy_started\") {\n        event.player = entities.getByUserId(event.userid);\n        event.entity = entities.entities.get(event.entityid);\n    }\n    else if (eventName === \"defuser_dropped\") {\n        event.entity = entities.entities.get(event.entityid);\n    }\n    else if (eventName === \"defuser_pickup\") {\n        event.entity = entities.entities.get(event.entityid);\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"flashbang_detonate\") {\n        event.player = entities.getByUserId(event.userid);\n        event.entity = entities.entities.get(event.entityid);\n    }\n    else if (eventName === \"hegrenade_detonate\") {\n        event.player = entities.getByUserId(event.userid);\n        event.entity = entities.entities.get(event.entityid);\n    }\n    else if (eventName === \"hostage_hurt\") {\n        event.player = entities.getByUserId(event.userid);\n        event.entity = entities.entities.get(event.hostage);\n    }\n    else if (eventName === \"hostage_killed\") {\n        event.player = entities.getByUserId(event.userid);\n        event.entity = entities.entities.get(event.hostage);\n    }\n    else if (eventName === \"hostage_rescued\") {\n        event.player = entities.getByUserId(event.userid);\n        event.entity = entities.entities.get(event.hostage);\n    }\n    else if (eventName === \"inferno_expire\") {\n        event.entity = entities.entities.get(event.entityid);\n    }\n    else if (eventName === \"inferno_startburn\") {\n        event.entity = entities.entities.get(event.entityid);\n    }\n    else if (eventName === \"item_equip\") {\n        event.player = entities.getByUserId(event.userid);\n        event.itemDefinition = itemdefs_1.itemDefinitionIndexMap[event.defindex] || null;\n    }\n    else if (eventName === \"item_pickup\") {\n        event.player = entities.getByUserId(event.userid);\n        event.itemDefinition = itemdefs_1.itemDefinitionIndexMap[event.defindex] || null;\n    }\n    else if (eventName === \"item_remove\") {\n        event.player = entities.getByUserId(event.userid);\n        event.itemDefinition = itemdefs_1.itemDefinitionIndexMap[event.defindex] || null;\n    }\n    else if (eventName === \"items_gifted\") {\n        event.entity = entities.getByAccountId(event.accountid);\n    }\n    else if (eventName === \"other_death\") {\n        event.victim = entities.entities.get(event.otherid);\n        event.attackerEntity = entities.getByUserId(event.attacker);\n        event.itemDefinition =\n            event.weapon_fauxitemid != \"\"\n                ? itemdefs_1.itemDefinitionIndexMap[Long.fromString(event.weapon_fauxitemid, true)\n                    .and(0xffff)\n                    .toString()]\n                : null;\n        event.paintKit =\n            event.weapon_fauxitemid != \"\"\n                ? itemdefs_1.paintKitIndexMap[Long.fromString(event.weapon_fauxitemid, true)\n                    .shiftRightUnsigned(16)\n                    .and(0xffff)\n                    .toString()]\n                : null;\n        event.originalOwner = entities.getBySteam64Id(event.weapon_originalowner_xuid);\n    }\n    else if (eventName === \"player_blind\") {\n        event.player = entities.getByUserId(event.userid);\n        event.attackerEntity = entities.getByUserId(event.attacker);\n        event.entity = entities.entities.get(event.entityid);\n    }\n    else if (eventName === \"player_changename\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"player_chat\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"player_connect_full\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"player_death\") {\n        event.player = entities.getByUserId(event.userid);\n        event.attackerEntity = entities.getByUserId(event.attacker);\n        event.assisterEntity = entities.getByUserId(event.assister);\n        event.itemDefinition =\n            event.weapon_fauxitemid != \"\"\n                ? itemdefs_1.itemDefinitionIndexMap[Long.fromString(event.weapon_fauxitemid, true)\n                    .and(0xffff)\n                    .toString()]\n                : null;\n        event.paintKit =\n            event.weapon_fauxitemid != \"\"\n                ? itemdefs_1.paintKitIndexMap[Long.fromString(event.weapon_fauxitemid, true)\n                    .shiftRightUnsigned(16)\n                    .and(0xffff)\n                    .toString()]\n                : null;\n        event.originalOwner = entities.getBySteam64Id(event.weapon_originalowner_xuid);\n    }\n    else if (eventName === \"player_disconnect\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"player_falldamage\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"player_footstep\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"player_hurt\") {\n        event.player = entities.getByUserId(event.userid);\n        event.attackerEntity = entities.getByUserId(event.attacker);\n    }\n    else if (eventName === \"player_info\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"player_jump\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"player_spawn\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"player_team\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"round_mvp\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"smokegrenade_detonate\") {\n        event.player = entities.getByUserId(event.userid);\n        event.entity = entities.entities.get(event.entityid);\n    }\n    else if (eventName === \"smokegrenade_expired\") {\n        event.player = entities.getByUserId(event.userid);\n        event.entity = entities.entities.get(event.entityid);\n    }\n    else if (eventName === \"survival_paradrop_break\") {\n        event.entity = entities.entities.get(event.entityid);\n    }\n    else if (eventName === \"survival_paradrop_spawn\") {\n        event.entity = entities.entities.get(event.entityid);\n    }\n    else if (eventName === \"tournament_reward\") {\n        event.itemDefinition = itemdefs_1.itemDefinitionIndexMap[event.defindex] || null;\n        event.entity = entities.getByAccountId(event.accountid);\n    }\n    else if (eventName === \"weapon_fire\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"weapon_fire_on_empty\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"weapon_outofammo\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"weapon_reload\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    else if (eventName === \"weapon_zoom\") {\n        event.player = entities.getByUserId(event.userid);\n    }\n    return event;\n}\nexports.annotateEvent = annotateEvent;\n//# sourceMappingURL=eventtypes.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.BitView = exports.BitStream = void 0;\n/* eslint-disable @typescript-eslint/unbound-method */\nconst bit_buffer_1 = require(\"bit-buffer\");\nObject.defineProperty(exports, \"BitStream\", { enumerable: true, get: function () { return bit_buffer_1.BitStream; } });\nObject.defineProperty(exports, \"BitView\", { enumerable: true, get: function () { return bit_buffer_1.BitView; } });\nconst COORD_INTEGER_BITS = 14;\nconst COORD_FRACTIONAL_BITS = 5;\nconst COORD_DENOMINATOR = 1 << COORD_FRACTIONAL_BITS;\nconst COORD_RESOLUTION = 1.0 / COORD_DENOMINATOR;\n// Special threshold for networking multiplayer origins\nconst COORD_INTEGER_BITS_MP = 11;\nconst COORD_FRACTIONAL_BITS_MP_LOWPRECISION = 3;\nconst COORD_DENOMINATOR_LOWPRECISION = 1 << COORD_FRACTIONAL_BITS_MP_LOWPRECISION;\nconst COORD_RESOLUTION_LOWPRECISION = 1.0 / COORD_DENOMINATOR_LOWPRECISION;\nconst NORMAL_FRACTIONAL_BITS = 11;\nconst NORMAL_DENOMINATOR = (1 << NORMAL_FRACTIONAL_BITS) - 1;\nconst NORMAL_RESOLUTION = 1.0 / NORMAL_DENOMINATOR;\nconst MAX_VAR_INT32_BYTES = 5;\nbit_buffer_1.BitStream.from = function from(array) {\n    return new bit_buffer_1.BitStream(array.buffer, array.byteOffset, array.byteLength);\n};\nbit_buffer_1.BitStream.prototype.readString = function (bytes) {\n    let s = \"\";\n    let record = true;\n    for (let i = 0; i < bytes; ++i) {\n        const c = this.readUint8();\n        // Stop appending chars once we hit 0x00\n        if (c === 0x00) {\n            record = false;\n        }\n        else if (record) {\n            s += String.fromCharCode(c);\n        }\n    }\n    return s;\n};\nbit_buffer_1.BitStream.prototype.readBytes = function (bytes) {\n    const arr = new Array(bytes);\n    for (let i = 0; i < bytes; ++i) {\n        arr[i] = this.readUInt8();\n    }\n    return Buffer.from(arr);\n};\nbit_buffer_1.BitStream.prototype.readOneBit = function () {\n    return this.readBits(1, false) === 1;\n};\nbit_buffer_1.BitStream.prototype.readUBits = bit_buffer_1.BitStream.prototype.readBits;\nbit_buffer_1.BitStream.prototype.readSBits = function (bits) {\n    return this.readBits(bits, true);\n};\nbit_buffer_1.BitStream.prototype.readUBitVar = function () {\n    let ret = this.readUBits(6);\n    switch (ret & (16 | 32)) {\n        case 16:\n            ret = (ret & 15) | (this.readUBits(4) << 4);\n            break;\n        case 32:\n            ret = (ret & 15) | (this.readUBits(8) << 4);\n            break;\n        case 48:\n            ret = (ret & 15) | (this.readUBits(32 - 4) << 4);\n            break;\n    }\n    return ret;\n};\nbit_buffer_1.BitStream.prototype.readBitCoord = function () {\n    let intval = this.readOneBit() ? 1 : 0;\n    let fractval = this.readOneBit() ? 1 : 0;\n    if (!intval && !fractval) {\n        return 0.0;\n    }\n    const signbit = this.readOneBit();\n    if (intval) {\n        intval = this.readUBits(COORD_INTEGER_BITS) + 1;\n    }\n    if (fractval) {\n        fractval = this.readUBits(COORD_FRACTIONAL_BITS);\n    }\n    let value = intval + fractval * COORD_RESOLUTION;\n    if (signbit) {\n        value = -value;\n    }\n    return value;\n};\nbit_buffer_1.BitStream.prototype.readUVarInt32 = function () {\n    let result = 0;\n    let count = 0;\n    let bytes;\n    do {\n        if (count === MAX_VAR_INT32_BYTES) {\n            return result;\n        }\n        bytes = this.readUInt8();\n        result |= (bytes & 0x7f) << (7 * count);\n        ++count;\n    } while (bytes & 0x80);\n    return result;\n};\nbit_buffer_1.BitStream.prototype.readVarInt32 = function () {\n    const result = this.readUVarInt32();\n    return (result >> 1) ^ -(result & 1);\n};\nbit_buffer_1.BitStream.prototype.readBitCoordMPNone = function () {\n    const inBounds = this.readOneBit();\n    let intval = this.readOneBit() ? 1 : 0;\n    const signbit = this.readOneBit();\n    if (intval) {\n        if (inBounds) {\n            intval = this.readUBits(COORD_INTEGER_BITS_MP) + 1;\n        }\n        else {\n            intval = this.readUBits(COORD_INTEGER_BITS) + 1;\n        }\n    }\n    const fractval = this.readUBits(COORD_FRACTIONAL_BITS);\n    let value = intval + fractval * COORD_RESOLUTION;\n    if (signbit) {\n        value = -value;\n    }\n    return value;\n};\nbit_buffer_1.BitStream.prototype.readBitCoordMPLowPrecision = function () {\n    const inBounds = this.readOneBit();\n    let intval = this.readOneBit() ? 1 : 0;\n    const signbit = this.readOneBit();\n    if (intval) {\n        if (inBounds) {\n            intval = this.readUBits(COORD_INTEGER_BITS_MP) + 1;\n        }\n        else {\n            intval = this.readUBits(COORD_INTEGER_BITS) + 1;\n        }\n    }\n    const fractval = this.readUBits(COORD_FRACTIONAL_BITS_MP_LOWPRECISION);\n    let value = intval + fractval * COORD_RESOLUTION_LOWPRECISION;\n    if (signbit) {\n        value = -value;\n    }\n    return value;\n};\nbit_buffer_1.BitStream.prototype.readBitCoordMPIntegral = function () {\n    const inBounds = this.readOneBit();\n    if (!this.readOneBit()) {\n        return 0.0;\n    }\n    const signbit = this.readOneBit();\n    let value;\n    if (inBounds) {\n        value = this.readUBits(COORD_INTEGER_BITS_MP) + 1;\n    }\n    else {\n        value = this.readUBits(COORD_INTEGER_BITS) + 1;\n    }\n    if (signbit) {\n        value = -value;\n    }\n    return value;\n};\nbit_buffer_1.BitStream.prototype.readBitNormal = function () {\n    const signbit = this.readOneBit();\n    const fractval = this.readUBits(NORMAL_FRACTIONAL_BITS);\n    let value = fractval * NORMAL_RESOLUTION;\n    if (signbit) {\n        value = -value;\n    }\n    return value;\n};\nbit_buffer_1.BitStream.prototype.readBitCellCoordNone = function (bits) {\n    const intval = this.readUBits(bits);\n    const fractval = this.readUBits(COORD_FRACTIONAL_BITS);\n    return intval + fractval * COORD_RESOLUTION;\n};\nbit_buffer_1.BitStream.prototype.readBitCellCoordLowPrecision = function (bits) {\n    const intval = this.readUBits(bits);\n    const fractval = this.readUBits(COORD_FRACTIONAL_BITS_MP_LOWPRECISION);\n    return intval + fractval * COORD_RESOLUTION_LOWPRECISION;\n};\nbit_buffer_1.BitStream.prototype.readBitCellCoordIntegral = function (bits) {\n    return this.readUBits(bits);\n};\nbit_buffer_1.BitStream.prototype.readCString = function () {\n    let s = \"\";\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n        const c = this.readUint8();\n        // Stop appending chars once we hit 0x00\n        if (c === 0x00) {\n            break;\n        }\n        s += String.fromCharCode(c);\n    }\n    return s;\n};\nbit_buffer_1.BitStream.prototype.readUInt8 = bit_buffer_1.BitStream.prototype.readUint8;\nbit_buffer_1.BitStream.prototype.readUInt16 = bit_buffer_1.BitStream.prototype.readUint16;\nbit_buffer_1.BitStream.prototype.readUInt32 = bit_buffer_1.BitStream.prototype.readUint32;\nbit_buffer_1.BitStream.prototype.writeUInt8 = bit_buffer_1.BitStream.prototype.writeUint8;\nbit_buffer_1.BitStream.prototype.writeUInt16 = bit_buffer_1.BitStream.prototype.writeUint16;\nbit_buffer_1.BitStream.prototype.writeUInt32 = bit_buffer_1.BitStream.prototype.writeUint32;\n//# sourceMappingURL=bitbuffer.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GameEvent = void 0;\nconst assert = require(\"assert\");\nvar EventKeyType;\n(function (EventKeyType) {\n    EventKeyType[EventKeyType[\"TYPE_STRING\"] = 1] = \"TYPE_STRING\";\n    EventKeyType[EventKeyType[\"TYPE_FLOAT\"] = 2] = \"TYPE_FLOAT\";\n    EventKeyType[EventKeyType[\"TYPE_LONG\"] = 3] = \"TYPE_LONG\";\n    EventKeyType[EventKeyType[\"TYPE_SHORT\"] = 4] = \"TYPE_SHORT\";\n    EventKeyType[EventKeyType[\"TYPE_BYTE\"] = 5] = \"TYPE_BYTE\";\n    EventKeyType[EventKeyType[\"TYPE_BOOL\"] = 6] = \"TYPE_BOOL\";\n    EventKeyType[EventKeyType[\"TYPE_UINT64\"] = 7] = \"TYPE_UINT64\";\n    EventKeyType[EventKeyType[\"TYPE_WSTRING\"] = 8] = \"TYPE_WSTRING\";\n})(EventKeyType || (EventKeyType = {}));\nclass GameEvent {\n    constructor(descriptor) {\n        this.name = descriptor.name;\n        this.id = descriptor.eventid;\n        this.keyNames = descriptor.keys.map(key => key.name);\n    }\n    messageToObject(eventMsg) {\n        assert(eventMsg.eventid === this.id);\n        const event = {};\n        for (let i = 0; i < this.keyNames.length; ++i) {\n            const keyName = this.keyNames[i];\n            const value = eventMsg.keys[i];\n            switch (value.type) {\n                case EventKeyType.TYPE_STRING:\n                    event[keyName] = value.valString;\n                    break;\n                case EventKeyType.TYPE_FLOAT:\n                    event[keyName] = value.valFloat;\n                    break;\n                case EventKeyType.TYPE_LONG:\n                    event[keyName] = value.valLong;\n                    break;\n                case EventKeyType.TYPE_SHORT:\n                    event[keyName] = value.valShort;\n                    break;\n                case EventKeyType.TYPE_BYTE:\n                    event[keyName] = value.valByte;\n                    break;\n                case EventKeyType.TYPE_BOOL:\n                    event[keyName] = value.valBool;\n                    break;\n                case EventKeyType.TYPE_UINT64:\n                    event[keyName] = value.valUint64;\n                    break;\n                case EventKeyType.TYPE_WSTRING:\n                    event[keyName] = value.valWstring;\n                    break;\n            }\n        }\n        return event;\n    }\n}\nexports.GameEvent = GameEvent;\n//# sourceMappingURL=gameevent.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.GameEvents = void 0;\nconst events_1 = require(\"events\");\nconst gameevent_1 = require(\"./gameevent\");\nconst eventtypes_1 = require(\"./eventtypes\");\n/**\n * Manages game events for a demo file.\n */\nclass GameEvents extends events_1.EventEmitter {\n    constructor() {\n        super(...arguments);\n        this.gameEventList = [];\n        this._tickEvents = [];\n    }\n    listen(demo) {\n        const entities = demo.entities;\n        demo.on(\"svc_GameEventList\", this._handleGameEventList.bind(this));\n        demo.on(\"svc_GameEvent\", msg => {\n            const event = this.gameEventList[msg.eventid];\n            if (!event) {\n                return;\n            }\n            const eventVars = event.messageToObject(msg);\n            // buffer game events until the end of the tick\n            this._tickEvents.push({\n                name: event.name,\n                event: (0, eventtypes_1.annotateEvent)(entities, event.name, eventVars)\n            });\n        });\n        demo.on(\"tickend\", () => {\n            this._tickEvents.forEach(event => {\n                this.emit(event.name, event.event);\n                this.emit(\"event\", {\n                    name: event.name,\n                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n                    event: event.event\n                });\n            });\n            this._tickEvents = [];\n        });\n    }\n    _handleGameEventList(msg) {\n        for (const descriptor of msg.descriptors) {\n            this.gameEventList[descriptor.eventid] = new gameevent_1.GameEvent(descriptor);\n        }\n    }\n}\nexports.GameEvents = GameEvents;\n//# sourceMappingURL=gameevents.js.map","\"use strict\";\n// Copied from https://github.com/DSergiu/node-ice\n// ---\n// The MIT License\n//\n// Copyright (c) 2010-2017 Google, Inc. http://angularjs.org\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.IceKey = void 0;\nclass IceKey {\n    // Create a new ICE key with the specified level.\n    constructor(level) {\n        this.cipherHolder = new Uint8Array(8);\n        this.plainHolder = new Uint8Array(8);\n        if (!IceKey.spBoxInitialised) {\n            this.spBoxInit();\n            IceKey.spBoxInitialised = true;\n        }\n        if (level < 1) {\n            this.size = 1;\n            this.rounds = 8;\n        }\n        else {\n            this.size = level;\n            this.rounds = level * 16;\n        }\n        this.keySchedule = [];\n        for (let i = 0; i < this.rounds; i++) {\n            this.keySchedule[i] = [];\n            for (let j = 0; j < 3; j++) {\n                this.keySchedule[i][j] = 0;\n            }\n        }\n    }\n    // Return the key size, in bytes.\n    keySize() {\n        return this.size * 8;\n    }\n    // Return the block size, in bytes.\n    blockSize() {\n        return 8;\n    }\n    // Set the key schedule of an ICE key.\n    set(key) {\n        const kb = new Uint16Array(4);\n        for (let i = 0; i < 4; i++)\n            kb[i] = 0;\n        if (this.rounds === 8) {\n            for (let i = 0; i < 4; i++)\n                kb[3 - i] = ((key[i * 2] & 0xff) << 8) | (key[i * 2 + 1] & 0xff);\n            this.scheduleBuild(kb, 0, 0);\n            return;\n        }\n        for (let i = 0; i < this.size; i++) {\n            for (let j = 0; j < 4; j++)\n                kb[3 - j] =\n                    ((key[i * 8 + j * 2] & 0xff) << 8) |\n                        (key[i * 8 + j * 2 + 1] & 0xff);\n            this.scheduleBuild(kb, i * 8, 0);\n            this.scheduleBuild(kb, this.rounds - 8 - i * 8, 8);\n        }\n    }\n    // Clear the key schedule to prevent memory snooping.\n    clear() {\n        for (let i = 0; i < this.rounds; i++)\n            for (let j = 0; j < 3; j++)\n                this.keySchedule[i][j] = 0;\n    }\n    // Encrypt a block of 8 bytes of data.\n    encrypt(plaintext, ciphertext) {\n        let i;\n        let l = 0;\n        let r = 0;\n        for (i = 0; i < 4; i++) {\n            l |= (plaintext[i] & 0xff) << (24 - i * 8);\n            r |= (plaintext[i + 4] & 0xff) << (24 - i * 8);\n        }\n        for (i = 0; i < this.rounds; i += 2) {\n            l ^= this.roundFunc(r, this.keySchedule[i]);\n            r ^= this.roundFunc(l, this.keySchedule[i + 1]);\n        }\n        for (i = 0; i < 4; i++) {\n            ciphertext[3 - i] = Number(r & 0xff);\n            ciphertext[7 - i] = Number(l & 0xff);\n            r >>>= 8;\n            l >>>= 8;\n        }\n    }\n    // Decrypt a block of 8 bytes of data.\n    decrypt(ciphertext, plaintext) {\n        let i;\n        let l = 0;\n        let r = 0;\n        for (i = 0; i < 4; i++) {\n            l |= (ciphertext[i] & 0xff) << (24 - i * 8);\n            r |= (ciphertext[i + 4] & 0xff) << (24 - i * 8);\n        }\n        for (i = this.rounds - 1; i > 0; i -= 2) {\n            l ^= this.roundFunc(r, this.keySchedule[i]);\n            r ^= this.roundFunc(l, this.keySchedule[i - 1]);\n        }\n        for (i = 0; i < 4; i++) {\n            plaintext[3 - i] = Number(r & 0xff);\n            plaintext[7 - i] = Number(l & 0xff);\n            r >>>= 8;\n            l >>>= 8;\n        }\n    }\n    decryptUint8Array(cipherArray, plainArray, from, to) {\n        if (from == null)\n            from = 0;\n        if (to == null)\n            to = cipherArray.length;\n        let k = 0;\n        // decrypt full blocks\n        while (from + 8 <= to) {\n            for (let i = 0; i < 8; i++) {\n                this.cipherHolder[i] = cipherArray[from + i];\n            }\n            this.decrypt(this.cipherHolder, this.plainHolder);\n            for (let i = 0; i < 8; i++) {\n                plainArray[k + i] = this.plainHolder[i];\n            }\n            k += 8;\n            from += 8;\n        }\n        // remaining bytes do not get encryption, just copy them\n        if (((to - from) & 0x7) !== 0) {\n            for (let i = from; i < to; i++) {\n                plainArray[k++] = cipherArray[i];\n            }\n        }\n    }\n    // 8-bit Galois Field multiplication of a by b, modulo m.\n    // Just like arithmetic multiplication, except that\n    // additions and subtractions are replaced by XOR.\n    gf_mult(a, b, m) {\n        let res = 0;\n        while (b !== 0) {\n            if ((b & 1) !== 0)\n                res ^= a;\n            a <<= 1;\n            b >>>= 1;\n            if (a >= 256)\n                a ^= m;\n        }\n        return res;\n    }\n    // 8-bit Galois Field exponentiation.\n    // Raise the base to the power of 7, modulo m.\n    gf_exp7(b, m) {\n        let x;\n        if (b === 0)\n            return 0;\n        x = this.gf_mult(b, b, m);\n        x = this.gf_mult(b, x, m);\n        x = this.gf_mult(x, x, m);\n        return this.gf_mult(b, x, m);\n    }\n    // Carry out the ICE 32-bit permutation.\n    perm32(x) {\n        let res = 0;\n        let i = 0;\n        while (x !== 0) {\n            if ((x & 1) !== 0)\n                res |= IceKey.pBox[i];\n            i++;\n            x >>>= 1;\n        }\n        return res;\n    }\n    // Initialise the substitution/permutation boxes.\n    spBoxInit() {\n        IceKey.spBox = [];\n        for (let i = 0; i < 4; i++) {\n            IceKey.spBox[i] = [];\n            for (let j = 0; j < 1024; j++) {\n                IceKey.spBox[i][j] = 0;\n            }\n        }\n        for (let i = 0; i < 1024; i++) {\n            const col = (i >>> 1) & 0xff;\n            const row = (i & 0x1) | ((i & 0x200) >>> 8);\n            let x;\n            x =\n                this.gf_exp7(col ^ IceKey.sXor[0][row], IceKey.sMod[0][row]) << 24;\n            IceKey.spBox[0][i] = this.perm32(x);\n            x =\n                this.gf_exp7(col ^ IceKey.sXor[1][row], IceKey.sMod[1][row]) << 16;\n            IceKey.spBox[1][i] = this.perm32(x);\n            x = this.gf_exp7(col ^ IceKey.sXor[2][row], IceKey.sMod[2][row]) << 8;\n            IceKey.spBox[2][i] = this.perm32(x);\n            x = this.gf_exp7(col ^ IceKey.sXor[3][row], IceKey.sMod[3][row]);\n            IceKey.spBox[3][i] = this.perm32(x);\n        }\n    }\n    // Set 8 rounds [n, n+7] of the key schedule of an ICE key.\n    scheduleBuild(kb, n, krotIdx) {\n        let i;\n        for (i = 0; i < 8; i++) {\n            let j;\n            const kr = IceKey.keyrot[krotIdx + i];\n            const subkey = this.keySchedule[n + i];\n            for (j = 0; j < 3; j++)\n                this.keySchedule[n + i][j] = 0;\n            for (j = 0; j < 15; j++) {\n                let k;\n                const curSk = j % 3;\n                for (k = 0; k < 4; k++) {\n                    const curKb = kb[(kr + k) & 3];\n                    const bit = curKb & 1;\n                    subkey[curSk] = (subkey[curSk] << 1) | bit;\n                    kb[(kr + k) & 3] = (curKb >>> 1) | ((bit ^ 1) << 15);\n                }\n            }\n        }\n    }\n    // The single round ICE f function.\n    roundFunc(p, subkey) {\n        const tl = ((p >>> 16) & 0x3ff) | (((p >>> 14) | (p << 18)) & 0xffc00);\n        const tr = (p & 0x3ff) | ((p << 2) & 0xffc00);\n        let al = subkey[2] & (tl ^ tr);\n        let ar = al ^ tr;\n        al ^= tl;\n        al ^= subkey[0];\n        ar ^= subkey[1];\n        return (IceKey.spBox[0][al >>> 10] |\n            IceKey.spBox[1][al & 0x3ff] |\n            IceKey.spBox[2][ar >>> 10] |\n            IceKey.spBox[3][ar & 0x3ff]);\n    }\n}\nexports.IceKey = IceKey;\nIceKey.spBoxInitialised = false;\nIceKey.sMod = [\n    [333, 313, 505, 369],\n    [379, 375, 319, 391],\n    [361, 445, 451, 397],\n    [397, 425, 395, 505]\n];\nIceKey.sXor = [\n    [0x83, 0x85, 0x9b, 0xcd],\n    [0xcc, 0xa7, 0xad, 0x41],\n    [0x4b, 0x2e, 0xd4, 0x33],\n    [0xea, 0xcb, 0x2e, 0x04]\n];\nIceKey.pBox = [\n    0x00000001, 0x00000080, 0x00000400, 0x00002000, 0x00080000, 0x00200000,\n    0x01000000, 0x40000000, 0x00000008, 0x00000020, 0x00000100, 0x00004000,\n    0x00010000, 0x00800000, 0x04000000, 0x20000000, 0x00000004, 0x00000010,\n    0x00000200, 0x00008000, 0x00020000, 0x00400000, 0x08000000, 0x10000000,\n    0x00000002, 0x00000040, 0x00000800, 0x00001000, 0x00040000, 0x00100000,\n    0x02000000, 0x80000000\n];\nIceKey.keyrot = [0, 1, 2, 3, 2, 1, 3, 0, 1, 3, 2, 0, 3, 1, 0, 2];\n//# sourceMappingURL=icekey.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.findByType = exports.findByName = exports.messages = void 0;\nconst netmessages_1 = require(\"./protobufs/netmessages\");\nexports.messages = [];\nexports.messages[netmessages_1.NETMessages.net_NOP] = { name: \"net_NOP\", class: netmessages_1.CNETMsgNOP };\nexports.messages[netmessages_1.NETMessages.net_Disconnect] = {\n    name: \"net_Disconnect\",\n    class: netmessages_1.CNETMsgDisconnect\n};\nexports.messages[netmessages_1.NETMessages.net_File] = { name: \"net_File\", class: netmessages_1.CNETMsgFile };\nexports.messages[netmessages_1.NETMessages.net_SplitScreenUser] = {\n    name: \"net_SplitScreenUser\",\n    class: netmessages_1.CNETMsgSplitScreenUser\n};\nexports.messages[netmessages_1.NETMessages.net_Tick] = { name: \"net_Tick\", class: netmessages_1.CNETMsgTick };\nexports.messages[netmessages_1.NETMessages.net_StringCmd] = {\n    name: \"net_StringCmd\",\n    class: netmessages_1.CNETMsgStringCmd\n};\nexports.messages[netmessages_1.NETMessages.net_SetConVar] = {\n    name: \"net_SetConVar\",\n    class: netmessages_1.CNETMsgSetConVar\n};\nexports.messages[netmessages_1.NETMessages.net_SignonState] = {\n    name: \"net_SignonState\",\n    class: netmessages_1.CNETMsgSignonState\n};\nexports.messages[netmessages_1.NETMessages.net_PlayerAvatarData] = {\n    name: \"net_PlayerAvatarData\",\n    class: netmessages_1.CNETMsgPlayerAvatarData\n};\nexports.messages[netmessages_1.SVCMessages.svc_ServerInfo] = {\n    name: \"svc_ServerInfo\",\n    class: netmessages_1.CSVCMsgServerInfo\n};\nexports.messages[netmessages_1.SVCMessages.svc_SendTable] = {\n    name: \"svc_SendTable\",\n    class: netmessages_1.CSVCMsgSendTable\n};\nexports.messages[netmessages_1.SVCMessages.svc_ClassInfo] = {\n    name: \"svc_ClassInfo\",\n    class: netmessages_1.CSVCMsgClassInfo\n};\nexports.messages[netmessages_1.SVCMessages.svc_SetPause] = {\n    name: \"svc_SetPause\",\n    class: netmessages_1.CSVCMsgSetPause\n};\nexports.messages[netmessages_1.SVCMessages.svc_CreateStringTable] = {\n    name: \"svc_CreateStringTable\",\n    class: netmessages_1.CSVCMsgCreateStringTable\n};\nexports.messages[netmessages_1.SVCMessages.svc_UpdateStringTable] = {\n    name: \"svc_UpdateStringTable\",\n    class: netmessages_1.CSVCMsgUpdateStringTable\n};\nexports.messages[netmessages_1.SVCMessages.svc_VoiceInit] = {\n    name: \"svc_VoiceInit\",\n    class: netmessages_1.CSVCMsgVoiceInit\n};\nexports.messages[netmessages_1.SVCMessages.svc_VoiceData] = {\n    name: \"svc_VoiceData\",\n    class: netmessages_1.CSVCMsgVoiceData\n};\nexports.messages[netmessages_1.SVCMessages.svc_Print] = { name: \"svc_Print\", class: netmessages_1.CSVCMsgPrint };\nexports.messages[netmessages_1.SVCMessages.svc_Sounds] = { name: \"svc_Sounds\", class: netmessages_1.CSVCMsgSounds };\nexports.messages[netmessages_1.SVCMessages.svc_SetView] = {\n    name: \"svc_SetView\",\n    class: netmessages_1.CSVCMsgSetView\n};\nexports.messages[netmessages_1.SVCMessages.svc_FixAngle] = {\n    name: \"svc_FixAngle\",\n    class: netmessages_1.CSVCMsgFixAngle\n};\nexports.messages[netmessages_1.SVCMessages.svc_CrosshairAngle] = {\n    name: \"svc_CrosshairAngle\",\n    class: netmessages_1.CSVCMsgCrosshairAngle\n};\nexports.messages[netmessages_1.SVCMessages.svc_BSPDecal] = {\n    name: \"svc_BSPDecal\",\n    class: netmessages_1.CSVCMsgBSPDecal\n};\nexports.messages[netmessages_1.SVCMessages.svc_SplitScreen] = {\n    name: \"svc_SplitScreen\",\n    class: netmessages_1.CSVCMsgSplitScreen\n};\nexports.messages[netmessages_1.SVCMessages.svc_UserMessage] = {\n    name: \"svc_UserMessage\",\n    class: netmessages_1.CSVCMsgUserMessage\n};\nexports.messages[netmessages_1.SVCMessages.svc_EntityMessage] = {\n    name: \"svc_EntityMessage\",\n    class: netmessages_1.CSVCMsgEntityMsg\n};\nexports.messages[netmessages_1.SVCMessages.svc_GameEvent] = {\n    name: \"svc_GameEvent\",\n    class: netmessages_1.CSVCMsgGameEvent\n};\nexports.messages[netmessages_1.SVCMessages.svc_PacketEntities] = {\n    name: \"svc_PacketEntities\",\n    class: netmessages_1.CSVCMsgPacketEntities\n};\nexports.messages[netmessages_1.SVCMessages.svc_TempEntities] = {\n    name: \"svc_TempEntities\",\n    class: netmessages_1.CSVCMsgTempEntities\n};\nexports.messages[netmessages_1.SVCMessages.svc_Prefetch] = {\n    name: \"svc_Prefetch\",\n    class: netmessages_1.CSVCMsgPrefetch\n};\nexports.messages[netmessages_1.SVCMessages.svc_Menu] = { name: \"svc_Menu\", class: netmessages_1.CSVCMsgMenu };\nexports.messages[netmessages_1.SVCMessages.svc_GameEventList] = {\n    name: \"svc_GameEventList\",\n    class: netmessages_1.CSVCMsgGameEventList\n};\nexports.messages[netmessages_1.SVCMessages.svc_GetCvarValue] = {\n    name: \"svc_GetCvarValue\",\n    class: netmessages_1.CSVCMsgGetCvarValue\n};\nexports.messages[netmessages_1.SVCMessages.svc_PaintmapData] = {\n    name: \"svc_PaintmapData\",\n    class: netmessages_1.CSVCMsgPaintmapData\n};\nexports.messages[netmessages_1.SVCMessages.svc_CmdKeyValues] = {\n    name: \"svc_CmdKeyValues\",\n    class: netmessages_1.CSVCMsgCmdKeyValues\n};\nexports.messages[netmessages_1.SVCMessages.svc_EncryptedData] = {\n    name: \"svc_EncryptedData\",\n    class: netmessages_1.CSVCMsgEncryptedData\n};\nexports.messages[netmessages_1.SVCMessages.svc_HltvReplay] = {\n    name: \"svc_HltvReplay\",\n    class: netmessages_1.CSVCMsgHltvReplay\n};\nexports.messages[netmessages_1.SVCMessages.svc_Broadcast_Command] = {\n    name: \"svc_Broadcast_Command\",\n    class: netmessages_1.CSVCMsgBroadcastCommand\n};\nfunction findByName(name) {\n    return exports.messages.find(descriptor => descriptor.name === name);\n}\nexports.findByName = findByName;\nfunction findByType(type) {\n    return exports.messages[type];\n}\nexports.findByType = findByType;\n//# sourceMappingURL=net.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.makeDecoder = exports.SPROP_VARINT = exports.SPROP_CHANGES_OFTEN = exports.SPROP_CELL_COORD_INTEGRAL = exports.SPROP_CELL_COORD_LOWPRECISION = exports.SPROP_CELL_COORD = exports.SPROP_COORD_MP_INTEGRAL = exports.SPROP_COORD_MP_LOWPRECISION = exports.SPROP_COORD_MP = exports.SPROP_COLLAPSIBLE = exports.SPROP_IS_A_VECTOR_ELEM = exports.SPROP_PROXY_ALWAYS_YES = exports.SPROP_INSIDEARRAY = exports.SPROP_XYZE = exports.SPROP_EXCLUDE = exports.SPROP_NORMAL = exports.SPROP_ROUNDUP = exports.SPROP_ROUNDDOWN = exports.SPROP_NOSCALE = exports.SPROP_COORD = exports.SPROP_UNSIGNED = void 0;\nconst assert = require(\"assert\");\nconst Long = require(\"long\");\nconst assert_exists_1 = require(\"./assert-exists\");\nconst consts_1 = require(\"./consts\");\nconst entityhandle_1 = require(\"./entityhandle\");\nexports.SPROP_UNSIGNED = 1 << 0; // Unsigned integer data.\nexports.SPROP_COORD = 1 << 1; // If this is set, the float/vector is treated like a world coordinate. Note that the bit count is ignored in this case.\nexports.SPROP_NOSCALE = 1 << 2; // For floating point, don't scale into range, just take value as is.\nexports.SPROP_ROUNDDOWN = 1 << 3; // For floating point, limit high value to range minus one bit unit\nexports.SPROP_ROUNDUP = 1 << 4; // For floating point, limit low value to range minus one bit unit\nexports.SPROP_NORMAL = 1 << 5; // If this is set, the vector is treated like a normal (only valid for vectors)\nexports.SPROP_EXCLUDE = 1 << 6; // This is an exclude prop (not excludED, but it points at another prop to be excluded).\nexports.SPROP_XYZE = 1 << 7; // Use XYZ/Exponent encoding for vectors.\nexports.SPROP_INSIDEARRAY = 1 << 8; // This tells us that the property is inside an array, so it shouldn't be put into the flattened property list. Its array will point at it when it needs to.\nexports.SPROP_PROXY_ALWAYS_YES = 1 << 9; // Set for datatable props using one of the default datatable proxies like SendProxy_DataTableToDataTable that always send the data to all clients.\nexports.SPROP_IS_A_VECTOR_ELEM = 1 << 10; // Set automatically if SPROP_VECTORELEM is used.\nexports.SPROP_COLLAPSIBLE = 1 << 11; // Set automatically if it's a datatable with an offset of 0 that doesn't change the pointer (ie: for all automatically-chained base classes).\nexports.SPROP_COORD_MP = 1 << 12; // Like SPROP_COORD, but special handling for multiplayer games\nexports.SPROP_COORD_MP_LOWPRECISION = 1 << 13; // Like SPROP_COORD, but special handling for multiplayer games where the fractional component only gets a 3 bits instead of 5\nexports.SPROP_COORD_MP_INTEGRAL = 1 << 14; // SPROP_COORD_MP, but coordinates are rounded to integral boundaries\nexports.SPROP_CELL_COORD = 1 << 15; // Like SPROP_COORD, but special encoding for cell coordinates that can't be negative, bit count indicate maximum value\nexports.SPROP_CELL_COORD_LOWPRECISION = 1 << 16; // Like SPROP_CELL_COORD, but special handling where the fractional component only gets a 3 bits instead of 5\nexports.SPROP_CELL_COORD_INTEGRAL = 1 << 17; // SPROP_CELL_COORD, but coordinates are rounded to integral boundaries\nexports.SPROP_CHANGES_OFTEN = 1 << 18; // this is an often changed field, moved to head of sendtable so it gets a small index\nexports.SPROP_VARINT = 1 << 19; // use var int encoded (google protobuf style), note you want to include SPROP_UNSIGNED if needed, its more efficient\nconst DT_MAX_STRING_BITS = 9;\nfunction makeIntDecoder(sendProp) {\n    if ((sendProp.flags & exports.SPROP_VARINT) !== 0) {\n        if ((sendProp.flags & exports.SPROP_UNSIGNED) !== 0) {\n            return bitbuf => bitbuf.readUVarInt32();\n        }\n        else {\n            return bitbuf => bitbuf.readVarInt32();\n        }\n    }\n    else {\n        const numBits = sendProp.numBits;\n        if ((sendProp.flags & exports.SPROP_UNSIGNED) !== 0) {\n            if ((sendProp.flags & exports.SPROP_NOSCALE) !== 0 &&\n                sendProp.numBits === consts_1.NUM_NETWORKED_EHANDLE_BITS) {\n                return bitbuf => new entityhandle_1.EntityHandle(bitbuf.readUBits(numBits));\n            }\n            else if (numBits === 1) {\n                return bitbuf => bitbuf.readOneBit();\n            }\n            else {\n                return bitbuf => bitbuf.readUBits(numBits);\n            }\n        }\n        else {\n            return bitbuf => bitbuf.readSBits(numBits);\n        }\n    }\n}\nfunction makeSpecialFloatDecoder(sendProp) {\n    if ((sendProp.flags & exports.SPROP_COORD) !== 0) {\n        return bitbuf => bitbuf.readBitCoord();\n    }\n    else if ((sendProp.flags & exports.SPROP_COORD_MP) !== 0) {\n        return bitbuf => bitbuf.readBitCoordMPNone();\n    }\n    else if ((sendProp.flags & exports.SPROP_COORD_MP_LOWPRECISION) !== 0) {\n        return bitbuf => bitbuf.readBitCoordMPLowPrecision();\n    }\n    else if ((sendProp.flags & exports.SPROP_COORD_MP_INTEGRAL) !== 0) {\n        return bitbuf => bitbuf.readBitCoordMPIntegral();\n    }\n    else if ((sendProp.flags & exports.SPROP_NOSCALE) !== 0) {\n        return bitbuf => bitbuf.readFloat32();\n    }\n    else if ((sendProp.flags & exports.SPROP_NORMAL) !== 0) {\n        return bitbuf => bitbuf.readBitNormal();\n    }\n    else if ((sendProp.flags & exports.SPROP_CELL_COORD) !== 0) {\n        return bitbuf => bitbuf.readBitCellCoordNone(sendProp.numBits);\n    }\n    else if ((sendProp.flags & exports.SPROP_CELL_COORD_LOWPRECISION) !== 0) {\n        return bitbuf => bitbuf.readBitCellCoordLowPrecision(sendProp.numBits);\n    }\n    else if ((sendProp.flags & exports.SPROP_CELL_COORD_INTEGRAL) !== 0) {\n        return bitbuf => bitbuf.readUBits(sendProp.numBits);\n    }\n    else {\n        return undefined;\n    }\n}\nfunction makeFloatDecoder(sendProp) {\n    const special = makeSpecialFloatDecoder(sendProp);\n    if (special !== undefined) {\n        return special;\n    }\n    const numBits = sendProp.numBits;\n    const maxValue = (1 << numBits) - 1;\n    const lowValue = sendProp.lowValue;\n    const highValue = sendProp.highValue;\n    return bitbuf => {\n        const interp = bitbuf.readUBits(numBits);\n        const fVal = interp / maxValue;\n        return lowValue + (highValue - lowValue) * fVal;\n    };\n}\nfunction makeVectorDecoder(sendProp) {\n    const floatDecode = makeFloatDecoder(sendProp);\n    const isNormal = (sendProp.flags & exports.SPROP_NORMAL) !== 0;\n    if (isNormal) {\n        return bitbuf => {\n            const v = {\n                x: floatDecode(bitbuf),\n                y: floatDecode(bitbuf),\n                z: 0.0\n            };\n            const signBit = bitbuf.readOneBit();\n            const v0v0v1v1 = v.x * v.x + v.y * v.y;\n            if (v0v0v1v1 < 1.0) {\n                v.z = Math.sqrt(1.0 - v0v0v1v1);\n            }\n            else {\n                v.z = 0.0;\n            }\n            if (signBit) {\n                v.z *= -1.0;\n            }\n            return v;\n        };\n    }\n    else {\n        return bitbuf => ({\n            x: floatDecode(bitbuf),\n            y: floatDecode(bitbuf),\n            z: floatDecode(bitbuf)\n        });\n    }\n}\nfunction makeVectorXYDecoder(sendProp) {\n    const floatDecode = makeFloatDecoder(sendProp);\n    return bitbuf => ({\n        x: floatDecode(bitbuf),\n        y: floatDecode(bitbuf),\n        z: 0.0\n    });\n}\nfunction makeStringDecoder(_sendProp) {\n    return bitbuf => {\n        const len = bitbuf.readUBits(DT_MAX_STRING_BITS);\n        return bitbuf.readString(len);\n    };\n}\nfunction makeInt64Decoder(sendProp) {\n    if ((sendProp.flags & exports.SPROP_VARINT) !== 0) {\n        if ((sendProp.flags & exports.SPROP_UNSIGNED) !== 0) {\n            throw new Error(\"64-bit unsigned varint not implemented\"); // TODO\n        }\n        else {\n            throw new Error(\"64-bit signed varint not implemented\"); // TODO\n        }\n    }\n    else {\n        const highBits = sendProp.numBits - 32;\n        if ((sendProp.flags & exports.SPROP_UNSIGNED) !== 0) {\n            return bitbuf => {\n                const lowInt = bitbuf.readUBits(32);\n                const highInt = bitbuf.readUBits(highBits);\n                return Long.fromBits(lowInt, highInt, false);\n            };\n        }\n        else {\n            return bitbuf => {\n                const neg = bitbuf.readOneBit();\n                const lowInt = bitbuf.readUBits(32);\n                const highInt = bitbuf.readUBits(highBits - 1);\n                return Long.fromBits(lowInt, highInt, !neg);\n            };\n        }\n    }\n}\nfunction makeValueDecoder(sendProp) {\n    switch (sendProp.type) {\n        case 0 /* PropType.Int */:\n            return makeIntDecoder(sendProp);\n        case 1 /* PropType.Float */:\n            return makeFloatDecoder(sendProp);\n        case 2 /* PropType.Vector */:\n            return makeVectorDecoder(sendProp);\n        case 3 /* PropType.VectorXY */:\n            return makeVectorXYDecoder(sendProp);\n        case 4 /* PropType.String */:\n            return makeStringDecoder(sendProp);\n        case 7 /* PropType.Int64 */:\n            return makeInt64Decoder(sendProp);\n        default:\n            throw new Error(`Unsupported send prop type ${sendProp.type}`);\n    }\n}\nfunction makeArrayDecoder(sendProp, arrayElementProp) {\n    const maxElements = sendProp.numElements;\n    const numBits = (Math.log2(maxElements) | 0) + 1;\n    const elementDecoder = makeValueDecoder(arrayElementProp);\n    return bitbuf => {\n        const numElements = bitbuf.readUBits(numBits);\n        const array = new Array(numElements);\n        for (let i = 0; i < numElements; ++i) {\n            array[i] = elementDecoder(bitbuf);\n        }\n        return array;\n    };\n}\nfunction makeDecoder(sendProp, arrayElementProp) {\n    const type = sendProp.type;\n    assert(type !== 6 /* PropType.DataTable */);\n    if (type === 5 /* PropType.Array */) {\n        return makeArrayDecoder(sendProp, (0, assert_exists_1.default)(arrayElementProp, \"array prop with no element prop\"));\n    }\n    else {\n        return makeValueDecoder(sendProp);\n    }\n}\nexports.makeDecoder = makeDecoder;\n//# sourceMappingURL=props.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.CMsgGCCStrike15V2MatchmakingServerRoundStats_DropInfo = exports.CMsgGCCStrike15V2MatchmakingServerRoundStats = exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve = exports.CMsgGCCStrike15V2MatchmakingServerReservationResponse = exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve = exports.CPreMatchInfoData_TeamStats = exports.CPreMatchInfoData = exports.CDataGCCStrike15V2TournamentMatchDraft_Entry = exports.CDataGCCStrike15V2TournamentMatchDraft = exports.CMsgGCCStrike15V2MatchmakingGC2ClientUpdate_Note = exports.CMsgGCCStrike15V2MatchmakingGC2ClientUpdate = exports.CMsgGCCStrike15V2MatchmakingClient2ServerPing = exports.CMsgGCCStrike15V2MatchmakingStop = exports.CMsgGCCStrike15V2MatchmakingStart = exports.CMsgGCCStrike15V2GC2ServerReservationUpdate = exports.CMsgGCCStrike15V2MatchmakingGC2ServerConfirm = exports.CMsgGCCStrike15V2MatchmakingGCOperationalStats = exports.CMsgGCServerQuestUpdateData = exports.DeepPlayerMatchEvent = exports.DeepPlayerStatsEntry = exports.PlayerQuestData_QuestItemData = exports.PlayerQuestData = exports.ScoreLeaderboardData_AccountEntries = exports.ScoreLeaderboardData_Entry = exports.ScoreLeaderboardData = exports.MatchEndItemUpdates = exports.XpProgressData = exports.CMsgCsgoSteamUserStatChange = exports.IpAddressMask = exports.ServerHltvInfo = exports.TournamentMatchSetup = exports.AccountActivity = exports.PlayerMedalsInfo = exports.PlayerCommendationInfo = exports.PlayerRankingInfo = exports.OperationalStatisticsPacket = exports.OperationalStatisticElement = exports.OperationalStatisticDescription = exports.GlobalStatistics = exports.TournamentEvent = exports.TournamentTeam = exports.TournamentPlayer = exports.DetailedSearchStatistic = exports.DataCenterPing = exports.GameServerPing = exports.EInitSystemResult = exports.EClientReportingVersion = exports.ECsgoSteamUserStat = exports.ECsgoGCMsg = exports.protobufPackage = void 0;\nexports.CMsgGCCStrike15V2MatchList = exports.CDataGCCStrike15V2TournamentInfo = exports.CDataGCCStrike15V2TournamentSection = exports.CDataGCCStrike15V2TournamentGroup_Picks = exports.CDataGCCStrike15V2TournamentGroup = exports.CDataGCCStrike15V2TournamentGroupTeam = exports.CDataGCCStrike15V2MatchInfo = exports.CMsgGCCStrike15V2MatchListRequestFullGameInfo = exports.CMsgGCCStrike15V2MatchListRequestTournamentGames = exports.CMsgGCCStrike15V2MatchListRequestRecentUserGames = exports.CMsgGCCStrike15V2MatchListRequestLiveGameForUser = exports.CMsgGCCStrike15V2MatchListRequestCurrentLiveGames = exports.CMsgGCCStrike15V2Client2GCEconPreviewDataBlockResponse = exports.CMsgGCCStrike15V2Client2GCEconPreviewDataBlockRequest = exports.CMsgItemAcknowledged = exports.CMsgGCCStrike15V2MatchEndRewardDropsNotification = exports.CEconItemPreviewDataBlock_Sticker = exports.CEconItemPreviewDataBlock = exports.CMsgGCCStrike15V2MatchEndRunRewardDrops = exports.CMsgGCCStrike15V2Client2GCTextMsg = exports.CMsgGCCStrike15V2GC2ClientTextMsg = exports.CClientHeaderOverwatchEvidence = exports.CMsgGCCStrike15V2PlayerOverwatchCaseStatus = exports.CMsgGCCStrike15V2PlayerOverwatchCaseAssignment = exports.CMsgGCCStrike15V2PlayerOverwatchCaseUpdate = exports.CMsgGCCStrike15V2PlayersProfile = exports.CMsgGCCStrike15V2ClientRequestPlayersProfile = exports.CMsgGCCStrike15V2WatchInfoUsers = exports.CMsgGCCStrike15ClientDeepStats_DeepStatsMatch = exports.CMsgGCCStrike15ClientDeepStats_DeepStatsRange = exports.CMsgGCCStrike15ClientDeepStats = exports.CMsgGCCstrike15V2GC2ServerNotifyXPRewarded = exports.CMsgGCCstrike15V2ClientRedeemMissionReward = exports.CMsgGCCstrike15V2ClientRequestNewMission = exports.CMsgGCCStrike15V2ClientRequestJoinServerData = exports.CMsgGCCStrike15V2ClientRequestJoinFriendData = exports.WatchableMatchInfo = exports.CMsgGCCStrike15V2ClientRequestWatchInfoFriends = exports.CMsgGCCStrike15V2ClientReportResponse = exports.CMsgGCCStrike15V2ClientReportServer = exports.CMsgGCCStrike15V2ClientCommendPlayer = exports.CMsgGCCStrike15V2ClientReportPlayer = exports.CMsgGCCStrike15V2ServerNotificationForUserPenalty = exports.CMsgGCCStrike15V2MatchmakingOperator2GCBlogUpdate = exports.CMsgGCCStrike15V2ClientGCRankUpdate = exports.CMsgGCCStrike15V2MatchmakingGC2ClientAbandon = exports.CMsgGCCStrike15V2AccountPrivacySettings_Setting = exports.CMsgGCCStrike15V2AccountPrivacySettings = exports.CMsgGCCStrike15V2MatchmakingGC2ClientHello = exports.CMsgGCCStrike15V2MatchmakingClient2GCHello = void 0;\nexports.CMsgGCCStrike15V2ClientPartyWarning = exports.CMsgGCCStrike15V2ClientPartyJoinRelay = exports.CMsgGCCStrike15V2ClientAccountBalance = exports.CMsgGCCStrike15V2ClientRequestSouvenir = exports.CMsgGCCStrike15V2ClientRequestOffers = exports.CMsgGCToClientSteamDatagramTicket = exports.CMsgGCCStrike15V2ClientToGCRequestTicket = exports.CMsgGCCStrike15V2AccountRequestCoPlays_Player = exports.CMsgGCCStrike15V2AccountRequestCoPlays = exports.CMsgGCCStrike15V2PartyInvite = exports.CMsgGCCStrike15V2PartySearchResults_Entry = exports.CMsgGCCStrike15V2PartySearchResults = exports.CMsgGCCStrike15V2PartySearch = exports.CMsgGCCStrike15V2PartyRegister = exports.CMsgGCCStrike15V2ClientPollState = exports.CMsgGCCStrike15V2ClientLogonFatalError = exports.CMsgGCCStrike15V2ClientPlayerDecalSign = exports.PlayerDecalDigitalSignature = exports.CMsgGCCStrike15GotvSyncPacket = exports.CMsgGCCStrike15V2ClientAuthKeyCode = exports.CMsgGCCStrike15V2GCToClientChat = exports.CMsgGCCStrike15V2ClientToGCChat = exports.CMsgGCCStrike15V2ClientToGCRequestElevate = exports.CMsgGCCStrike15V2Client2GCStreamUnlock = exports.CMsgGCCStrike15V2Client2GCRequestPrestigeCoin = exports.CMsgGCCStrike15V2AcknowledgePenalty = exports.CMsgGCGlobalGamePlay = exports.CMsgGCGlobalGameUnsubscribe = exports.CMsgGCGlobalGameSubscribe = exports.CSOPersonaDataPublic = exports.CSOAccountRecurringSubscription = exports.CSOAccountSeasonalOperation = exports.CSOQuestProgress = exports.CSOEconCoupon = exports.CMsgGCCStrike15V2GC2ClientTournamentInfo = exports.CMsgGCCStrike15V2Server2GCClientValidate = exports.CMsgGCCStrike15V2ClientSubmitSurveyVote = exports.CMsgGCCStrike15V2GiftsLeaderboardResponse_GiftLeaderboardEntry = exports.CMsgGCCStrike15V2GiftsLeaderboardResponse = exports.CMsgGCCStrike15V2GiftsLeaderboardRequest = exports.CMsgGCCStrike15V2ServerVarValueNotificationInfo = exports.CMsgGCCStrike15V2ClientVarValueNotificationInfo = exports.CMsgCStrike15Welcome = exports.CAttributeString = exports.CMsgGCCStrike15V2Fantasy_FantasyTeam = exports.CMsgGCCStrike15V2Fantasy_FantasySlot = exports.CMsgGCCStrike15V2Fantasy = exports.CMsgGCCStrike15V2Predictions_GroupMatchTeamPick = exports.CMsgGCCStrike15V2Predictions = exports.CMsgGCCStrike15V2MatchListTournamentOperatorMgmt = void 0;\nexports.CMsgGCCStrike15V2GC2ClientInitSystemResponse = exports.CMsgGCCStrike15V2GC2ClientInitSystem = exports.CMsgGCCStrike15V2GC2ClientRequestValidation = exports.CMsgGCCStrike15V2GC2ClientRefuseSecureMode = exports.CMsgGCCStrike15V2ClientReportValidation = exports.CVDiagnostic = exports.CMsgGCCStrike15V2ClientPerfReport_Entry = exports.CMsgGCCStrike15V2ClientPerfReport = exports.CMsgGCCStrike15V2GetEventFavoritesResponse = exports.CMsgGCCStrike15V2GetEventFavoritesRequest = exports.CMsgGCCStrike15V2SetEventFavorite = exports.CMsgGCCStrike15V2ClientPartyWarning_Entry = void 0;\n/* eslint-disable */\nconst minimal_1 = require(\"protobufjs/minimal\");\nconst Long = require(\"long\");\nconst engine_gcmessages_1 = require(\"./engine_gcmessages\");\nexports.protobufPackage = \"\";\nvar ECsgoGCMsg;\n(function (ECsgoGCMsg) {\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_Base\"] = 9100] = \"k_EMsgGCCStrike15_v2_Base\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchmakingStart\"] = 9101] = \"k_EMsgGCCStrike15_v2_MatchmakingStart\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchmakingStop\"] = 9102] = \"k_EMsgGCCStrike15_v2_MatchmakingStop\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchmakingClient2ServerPing\"] = 9103] = \"k_EMsgGCCStrike15_v2_MatchmakingClient2ServerPing\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchmakingGC2ClientUpdate\"] = 9104] = \"k_EMsgGCCStrike15_v2_MatchmakingGC2ClientUpdate\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchmakingServerReservationResponse\"] = 9106] = \"k_EMsgGCCStrike15_v2_MatchmakingServerReservationResponse\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchmakingGC2ClientReserve\"] = 9107] = \"k_EMsgGCCStrike15_v2_MatchmakingGC2ClientReserve\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchmakingClient2GCHello\"] = 9109] = \"k_EMsgGCCStrike15_v2_MatchmakingClient2GCHello\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchmakingGC2ClientHello\"] = 9110] = \"k_EMsgGCCStrike15_v2_MatchmakingGC2ClientHello\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchmakingGC2ClientAbandon\"] = 9112] = \"k_EMsgGCCStrike15_v2_MatchmakingGC2ClientAbandon\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchmakingGCOperationalStats\"] = 9115] = \"k_EMsgGCCStrike15_v2_MatchmakingGCOperationalStats\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchmakingOperator2GCBlogUpdate\"] = 9117] = \"k_EMsgGCCStrike15_v2_MatchmakingOperator2GCBlogUpdate\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ServerNotificationForUserPenalty\"] = 9118] = \"k_EMsgGCCStrike15_v2_ServerNotificationForUserPenalty\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientReportPlayer\"] = 9119] = \"k_EMsgGCCStrike15_v2_ClientReportPlayer\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientReportServer\"] = 9120] = \"k_EMsgGCCStrike15_v2_ClientReportServer\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientCommendPlayer\"] = 9121] = \"k_EMsgGCCStrike15_v2_ClientCommendPlayer\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientReportResponse\"] = 9122] = \"k_EMsgGCCStrike15_v2_ClientReportResponse\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientCommendPlayerQuery\"] = 9123] = \"k_EMsgGCCStrike15_v2_ClientCommendPlayerQuery\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientCommendPlayerQueryResponse\"] = 9124] = \"k_EMsgGCCStrike15_v2_ClientCommendPlayerQueryResponse\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_WatchInfoUsers\"] = 9126] = \"k_EMsgGCCStrike15_v2_WatchInfoUsers\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientRequestPlayersProfile\"] = 9127] = \"k_EMsgGCCStrike15_v2_ClientRequestPlayersProfile\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_PlayersProfile\"] = 9128] = \"k_EMsgGCCStrike15_v2_PlayersProfile\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_PlayerOverwatchCaseUpdate\"] = 9131] = \"k_EMsgGCCStrike15_v2_PlayerOverwatchCaseUpdate\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_PlayerOverwatchCaseAssignment\"] = 9132] = \"k_EMsgGCCStrike15_v2_PlayerOverwatchCaseAssignment\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_PlayerOverwatchCaseStatus\"] = 9133] = \"k_EMsgGCCStrike15_v2_PlayerOverwatchCaseStatus\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_GC2ClientTextMsg\"] = 9134] = \"k_EMsgGCCStrike15_v2_GC2ClientTextMsg\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_Client2GCTextMsg\"] = 9135] = \"k_EMsgGCCStrike15_v2_Client2GCTextMsg\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchEndRunRewardDrops\"] = 9136] = \"k_EMsgGCCStrike15_v2_MatchEndRunRewardDrops\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchEndRewardDropsNotification\"] = 9137] = \"k_EMsgGCCStrike15_v2_MatchEndRewardDropsNotification\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientRequestWatchInfoFriends2\"] = 9138] = \"k_EMsgGCCStrike15_v2_ClientRequestWatchInfoFriends2\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchList\"] = 9139] = \"k_EMsgGCCStrike15_v2_MatchList\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchListRequestCurrentLiveGames\"] = 9140] = \"k_EMsgGCCStrike15_v2_MatchListRequestCurrentLiveGames\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchListRequestRecentUserGames\"] = 9141] = \"k_EMsgGCCStrike15_v2_MatchListRequestRecentUserGames\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_GC2ServerReservationUpdate\"] = 9142] = \"k_EMsgGCCStrike15_v2_GC2ServerReservationUpdate\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientVarValueNotificationInfo\"] = 9144] = \"k_EMsgGCCStrike15_v2_ClientVarValueNotificationInfo\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchListRequestTournamentGames\"] = 9146] = \"k_EMsgGCCStrike15_v2_MatchListRequestTournamentGames\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchListRequestFullGameInfo\"] = 9147] = \"k_EMsgGCCStrike15_v2_MatchListRequestFullGameInfo\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_GiftsLeaderboardRequest\"] = 9148] = \"k_EMsgGCCStrike15_v2_GiftsLeaderboardRequest\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_GiftsLeaderboardResponse\"] = 9149] = \"k_EMsgGCCStrike15_v2_GiftsLeaderboardResponse\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ServerVarValueNotificationInfo\"] = 9150] = \"k_EMsgGCCStrike15_v2_ServerVarValueNotificationInfo\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientSubmitSurveyVote\"] = 9152] = \"k_EMsgGCCStrike15_v2_ClientSubmitSurveyVote\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_Server2GCClientValidate\"] = 9153] = \"k_EMsgGCCStrike15_v2_Server2GCClientValidate\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchListRequestLiveGameForUser\"] = 9154] = \"k_EMsgGCCStrike15_v2_MatchListRequestLiveGameForUser\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_Client2GCEconPreviewDataBlockRequest\"] = 9156] = \"k_EMsgGCCStrike15_v2_Client2GCEconPreviewDataBlockRequest\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_Client2GCEconPreviewDataBlockResponse\"] = 9157] = \"k_EMsgGCCStrike15_v2_Client2GCEconPreviewDataBlockResponse\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_AccountPrivacySettings\"] = 9158] = \"k_EMsgGCCStrike15_v2_AccountPrivacySettings\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_SetMyActivityInfo\"] = 9159] = \"k_EMsgGCCStrike15_v2_SetMyActivityInfo\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchListRequestTournamentPredictions\"] = 9160] = \"k_EMsgGCCStrike15_v2_MatchListRequestTournamentPredictions\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchListUploadTournamentPredictions\"] = 9161] = \"k_EMsgGCCStrike15_v2_MatchListUploadTournamentPredictions\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_DraftSummary\"] = 9162] = \"k_EMsgGCCStrike15_v2_DraftSummary\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientRequestJoinFriendData\"] = 9163] = \"k_EMsgGCCStrike15_v2_ClientRequestJoinFriendData\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientRequestJoinServerData\"] = 9164] = \"k_EMsgGCCStrike15_v2_ClientRequestJoinServerData\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientRequestNewMission\"] = 9165] = \"k_EMsgGCCStrike15_v2_ClientRequestNewMission\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_GC2ClientTournamentInfo\"] = 9167] = \"k_EMsgGCCStrike15_v2_GC2ClientTournamentInfo\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGC_GlobalGame_Subscribe\"] = 9168] = \"k_EMsgGC_GlobalGame_Subscribe\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGC_GlobalGame_Unsubscribe\"] = 9169] = \"k_EMsgGC_GlobalGame_Unsubscribe\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGC_GlobalGame_Play\"] = 9170] = \"k_EMsgGC_GlobalGame_Play\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_AcknowledgePenalty\"] = 9171] = \"k_EMsgGCCStrike15_v2_AcknowledgePenalty\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_Client2GCRequestPrestigeCoin\"] = 9172] = \"k_EMsgGCCStrike15_v2_Client2GCRequestPrestigeCoin\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_GC2ClientGlobalStats\"] = 9173] = \"k_EMsgGCCStrike15_v2_GC2ClientGlobalStats\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_Client2GCStreamUnlock\"] = 9174] = \"k_EMsgGCCStrike15_v2_Client2GCStreamUnlock\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_FantasyRequestClientData\"] = 9175] = \"k_EMsgGCCStrike15_v2_FantasyRequestClientData\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_FantasyUpdateClientData\"] = 9176] = \"k_EMsgGCCStrike15_v2_FantasyUpdateClientData\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_GCToClientSteamdatagramTicket\"] = 9177] = \"k_EMsgGCCStrike15_v2_GCToClientSteamdatagramTicket\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientToGCRequestTicket\"] = 9178] = \"k_EMsgGCCStrike15_v2_ClientToGCRequestTicket\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientToGCRequestElevate\"] = 9179] = \"k_EMsgGCCStrike15_v2_ClientToGCRequestElevate\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_GlobalChat\"] = 9180] = \"k_EMsgGCCStrike15_v2_GlobalChat\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_GlobalChat_Subscribe\"] = 9181] = \"k_EMsgGCCStrike15_v2_GlobalChat_Subscribe\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_GlobalChat_Unsubscribe\"] = 9182] = \"k_EMsgGCCStrike15_v2_GlobalChat_Unsubscribe\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientAuthKeyCode\"] = 9183] = \"k_EMsgGCCStrike15_v2_ClientAuthKeyCode\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_GotvSyncPacket\"] = 9184] = \"k_EMsgGCCStrike15_v2_GotvSyncPacket\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientPlayerDecalSign\"] = 9185] = \"k_EMsgGCCStrike15_v2_ClientPlayerDecalSign\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientLogonFatalError\"] = 9187] = \"k_EMsgGCCStrike15_v2_ClientLogonFatalError\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientPollState\"] = 9188] = \"k_EMsgGCCStrike15_v2_ClientPollState\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_Party_Register\"] = 9189] = \"k_EMsgGCCStrike15_v2_Party_Register\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_Party_Unregister\"] = 9190] = \"k_EMsgGCCStrike15_v2_Party_Unregister\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_Party_Search\"] = 9191] = \"k_EMsgGCCStrike15_v2_Party_Search\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_Party_Invite\"] = 9192] = \"k_EMsgGCCStrike15_v2_Party_Invite\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_Account_RequestCoPlays\"] = 9193] = \"k_EMsgGCCStrike15_v2_Account_RequestCoPlays\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientGCRankUpdate\"] = 9194] = \"k_EMsgGCCStrike15_v2_ClientGCRankUpdate\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientRequestOffers\"] = 9195] = \"k_EMsgGCCStrike15_v2_ClientRequestOffers\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientAccountBalance\"] = 9196] = \"k_EMsgGCCStrike15_v2_ClientAccountBalance\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientPartyJoinRelay\"] = 9197] = \"k_EMsgGCCStrike15_v2_ClientPartyJoinRelay\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientPartyWarning\"] = 9198] = \"k_EMsgGCCStrike15_v2_ClientPartyWarning\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_SetEventFavorite\"] = 9200] = \"k_EMsgGCCStrike15_v2_SetEventFavorite\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_GetEventFavorites_Request\"] = 9201] = \"k_EMsgGCCStrike15_v2_GetEventFavorites_Request\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientPerfReport\"] = 9202] = \"k_EMsgGCCStrike15_v2_ClientPerfReport\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_GetEventFavorites_Response\"] = 9203] = \"k_EMsgGCCStrike15_v2_GetEventFavorites_Response\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientRequestSouvenir\"] = 9204] = \"k_EMsgGCCStrike15_v2_ClientRequestSouvenir\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientReportValidation\"] = 9205] = \"k_EMsgGCCStrike15_v2_ClientReportValidation\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_GC2ClientRefuseSecureMode\"] = 9206] = \"k_EMsgGCCStrike15_v2_GC2ClientRefuseSecureMode\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_GC2ClientRequestValidation\"] = 9207] = \"k_EMsgGCCStrike15_v2_GC2ClientRequestValidation\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_ClientRedeemMissionReward\"] = 9209] = \"k_EMsgGCCStrike15_v2_ClientRedeemMissionReward\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_ClientDeepStats\"] = 9210] = \"k_EMsgGCCStrike15_ClientDeepStats\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_StartAgreementSessionInGame\"] = 9211] = \"k_EMsgGCCStrike15_StartAgreementSessionInGame\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_GC2ClientInitSystem\"] = 9212] = \"k_EMsgGCCStrike15_v2_GC2ClientInitSystem\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_GC2ClientInitSystem_Response\"] = 9213] = \"k_EMsgGCCStrike15_v2_GC2ClientInitSystem_Response\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_PrivateQueues\"] = 9214] = \"k_EMsgGCCStrike15_v2_PrivateQueues\";\n    ECsgoGCMsg[ECsgoGCMsg[\"k_EMsgGCCStrike15_v2_MatchListTournamentOperatorMgmt\"] = 9215] = \"k_EMsgGCCStrike15_v2_MatchListTournamentOperatorMgmt\";\n})(ECsgoGCMsg = exports.ECsgoGCMsg || (exports.ECsgoGCMsg = {}));\nvar ECsgoSteamUserStat;\n(function (ECsgoSteamUserStat) {\n    ECsgoSteamUserStat[ECsgoSteamUserStat[\"k_ECsgoSteamUserStat_XpEarnedGames\"] = 1] = \"k_ECsgoSteamUserStat_XpEarnedGames\";\n    ECsgoSteamUserStat[ECsgoSteamUserStat[\"k_ECsgoSteamUserStat_MatchWinsCompetitive\"] = 2] = \"k_ECsgoSteamUserStat_MatchWinsCompetitive\";\n    ECsgoSteamUserStat[ECsgoSteamUserStat[\"k_ECsgoSteamUserStat_SurvivedDangerZone\"] = 3] = \"k_ECsgoSteamUserStat_SurvivedDangerZone\";\n})(ECsgoSteamUserStat = exports.ECsgoSteamUserStat || (exports.ECsgoSteamUserStat = {}));\nvar EClientReportingVersion;\n(function (EClientReportingVersion) {\n    EClientReportingVersion[EClientReportingVersion[\"k_EClientReportingVersion_OldVersion\"] = 0] = \"k_EClientReportingVersion_OldVersion\";\n    EClientReportingVersion[EClientReportingVersion[\"k_EClientReportingVersion_BetaVersion\"] = 1] = \"k_EClientReportingVersion_BetaVersion\";\n    EClientReportingVersion[EClientReportingVersion[\"k_EClientReportingVersion_SupportsTrustedMode\"] = 2] = \"k_EClientReportingVersion_SupportsTrustedMode\";\n})(EClientReportingVersion = exports.EClientReportingVersion || (exports.EClientReportingVersion = {}));\nvar EInitSystemResult;\n(function (EInitSystemResult) {\n    EInitSystemResult[EInitSystemResult[\"k_EInitSystemResult_Invalid\"] = 0] = \"k_EInitSystemResult_Invalid\";\n    EInitSystemResult[EInitSystemResult[\"k_EInitSystemResult_Success\"] = 1] = \"k_EInitSystemResult_Success\";\n    EInitSystemResult[EInitSystemResult[\"k_EInitSystemResult_None\"] = 2] = \"k_EInitSystemResult_None\";\n    EInitSystemResult[EInitSystemResult[\"k_EInitSystemResult_NotFound\"] = 3] = \"k_EInitSystemResult_NotFound\";\n    EInitSystemResult[EInitSystemResult[\"k_EInitSystemResult_Existing\"] = 4] = \"k_EInitSystemResult_Existing\";\n    EInitSystemResult[EInitSystemResult[\"k_EInitSystemResult_FailedOpen\"] = 5] = \"k_EInitSystemResult_FailedOpen\";\n    EInitSystemResult[EInitSystemResult[\"k_EInitSystemResult_Mismatch\"] = 6] = \"k_EInitSystemResult_Mismatch\";\n    EInitSystemResult[EInitSystemResult[\"k_EInitSystemResult_FailedInit\"] = 7] = \"k_EInitSystemResult_FailedInit\";\n    EInitSystemResult[EInitSystemResult[\"k_EInitSystemResult_Max\"] = 8] = \"k_EInitSystemResult_Max\";\n})(EInitSystemResult = exports.EInitSystemResult || (exports.EInitSystemResult = {}));\nfunction createBaseGameServerPing() {\n    return { ping: 0, ip: 0, instances: 0 };\n}\nexports.GameServerPing = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.ping !== 0) {\n            writer.uint32(16).int32(message.ping);\n        }\n        if (message.ip !== 0) {\n            writer.uint32(24).uint32(message.ip);\n        }\n        if (message.instances !== 0) {\n            writer.uint32(40).uint32(message.instances);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseGameServerPing();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 2:\n                    message.ping = reader.int32();\n                    break;\n                case 3:\n                    message.ip = reader.uint32();\n                    break;\n                case 5:\n                    message.instances = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseGameServerPing();\n        message.ping = (_a = object.ping) !== null && _a !== void 0 ? _a : 0;\n        message.ip = (_b = object.ip) !== null && _b !== void 0 ? _b : 0;\n        message.instances = (_c = object.instances) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseDataCenterPing() {\n    return { dataCenterId: 0, ping: 0 };\n}\nexports.DataCenterPing = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.dataCenterId !== 0) {\n            writer.uint32(13).fixed32(message.dataCenterId);\n        }\n        if (message.ping !== 0) {\n            writer.uint32(16).sint32(message.ping);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseDataCenterPing();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.dataCenterId = reader.fixed32();\n                    break;\n                case 2:\n                    message.ping = reader.sint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseDataCenterPing();\n        message.dataCenterId = (_a = object.dataCenterId) !== null && _a !== void 0 ? _a : 0;\n        message.ping = (_b = object.ping) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseDetailedSearchStatistic() {\n    return { gameType: 0, searchTimeAvg: 0, playersSearching: 0 };\n}\nexports.DetailedSearchStatistic = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.gameType !== 0) {\n            writer.uint32(8).uint32(message.gameType);\n        }\n        if (message.searchTimeAvg !== 0) {\n            writer.uint32(16).uint32(message.searchTimeAvg);\n        }\n        if (message.playersSearching !== 0) {\n            writer.uint32(32).uint32(message.playersSearching);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseDetailedSearchStatistic();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.gameType = reader.uint32();\n                    break;\n                case 2:\n                    message.searchTimeAvg = reader.uint32();\n                    break;\n                case 4:\n                    message.playersSearching = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseDetailedSearchStatistic();\n        message.gameType = (_a = object.gameType) !== null && _a !== void 0 ? _a : 0;\n        message.searchTimeAvg = (_b = object.searchTimeAvg) !== null && _b !== void 0 ? _b : 0;\n        message.playersSearching = (_c = object.playersSearching) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseTournamentPlayer() {\n    return {\n        accountId: 0,\n        playerNick: \"\",\n        playerName: \"\",\n        playerDob: 0,\n        playerFlag: \"\",\n        playerLocation: \"\",\n        playerDesc: \"\"\n    };\n}\nexports.TournamentPlayer = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountId !== 0) {\n            writer.uint32(8).uint32(message.accountId);\n        }\n        if (message.playerNick !== \"\") {\n            writer.uint32(18).string(message.playerNick);\n        }\n        if (message.playerName !== \"\") {\n            writer.uint32(26).string(message.playerName);\n        }\n        if (message.playerDob !== 0) {\n            writer.uint32(32).uint32(message.playerDob);\n        }\n        if (message.playerFlag !== \"\") {\n            writer.uint32(42).string(message.playerFlag);\n        }\n        if (message.playerLocation !== \"\") {\n            writer.uint32(50).string(message.playerLocation);\n        }\n        if (message.playerDesc !== \"\") {\n            writer.uint32(58).string(message.playerDesc);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseTournamentPlayer();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountId = reader.uint32();\n                    break;\n                case 2:\n                    message.playerNick = reader.string();\n                    break;\n                case 3:\n                    message.playerName = reader.string();\n                    break;\n                case 4:\n                    message.playerDob = reader.uint32();\n                    break;\n                case 5:\n                    message.playerFlag = reader.string();\n                    break;\n                case 6:\n                    message.playerLocation = reader.string();\n                    break;\n                case 7:\n                    message.playerDesc = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g;\n        const message = createBaseTournamentPlayer();\n        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;\n        message.playerNick = (_b = object.playerNick) !== null && _b !== void 0 ? _b : \"\";\n        message.playerName = (_c = object.playerName) !== null && _c !== void 0 ? _c : \"\";\n        message.playerDob = (_d = object.playerDob) !== null && _d !== void 0 ? _d : 0;\n        message.playerFlag = (_e = object.playerFlag) !== null && _e !== void 0 ? _e : \"\";\n        message.playerLocation = (_f = object.playerLocation) !== null && _f !== void 0 ? _f : \"\";\n        message.playerDesc = (_g = object.playerDesc) !== null && _g !== void 0 ? _g : \"\";\n        return message;\n    }\n};\nfunction createBaseTournamentTeam() {\n    return { teamId: 0, teamTag: \"\", teamFlag: \"\", teamName: \"\", players: [] };\n}\nexports.TournamentTeam = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.teamId !== 0) {\n            writer.uint32(8).int32(message.teamId);\n        }\n        if (message.teamTag !== \"\") {\n            writer.uint32(18).string(message.teamTag);\n        }\n        if (message.teamFlag !== \"\") {\n            writer.uint32(26).string(message.teamFlag);\n        }\n        if (message.teamName !== \"\") {\n            writer.uint32(34).string(message.teamName);\n        }\n        for (const v of message.players) {\n            exports.TournamentPlayer.encode(v, writer.uint32(42).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseTournamentTeam();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.teamId = reader.int32();\n                    break;\n                case 2:\n                    message.teamTag = reader.string();\n                    break;\n                case 3:\n                    message.teamFlag = reader.string();\n                    break;\n                case 4:\n                    message.teamName = reader.string();\n                    break;\n                case 5:\n                    message.players.push(exports.TournamentPlayer.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseTournamentTeam();\n        message.teamId = (_a = object.teamId) !== null && _a !== void 0 ? _a : 0;\n        message.teamTag = (_b = object.teamTag) !== null && _b !== void 0 ? _b : \"\";\n        message.teamFlag = (_c = object.teamFlag) !== null && _c !== void 0 ? _c : \"\";\n        message.teamName = (_d = object.teamName) !== null && _d !== void 0 ? _d : \"\";\n        message.players =\n            ((_e = object.players) === null || _e === void 0 ? void 0 : _e.map(e => exports.TournamentPlayer.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseTournamentEvent() {\n    return {\n        eventId: 0,\n        eventTag: \"\",\n        eventName: \"\",\n        eventTimeStart: 0,\n        eventTimeEnd: 0,\n        eventPublic: 0,\n        eventStageId: 0,\n        eventStageName: \"\",\n        activeSectionId: 0\n    };\n}\nexports.TournamentEvent = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.eventId !== 0) {\n            writer.uint32(8).int32(message.eventId);\n        }\n        if (message.eventTag !== \"\") {\n            writer.uint32(18).string(message.eventTag);\n        }\n        if (message.eventName !== \"\") {\n            writer.uint32(26).string(message.eventName);\n        }\n        if (message.eventTimeStart !== 0) {\n            writer.uint32(32).uint32(message.eventTimeStart);\n        }\n        if (message.eventTimeEnd !== 0) {\n            writer.uint32(40).uint32(message.eventTimeEnd);\n        }\n        if (message.eventPublic !== 0) {\n            writer.uint32(48).int32(message.eventPublic);\n        }\n        if (message.eventStageId !== 0) {\n            writer.uint32(56).int32(message.eventStageId);\n        }\n        if (message.eventStageName !== \"\") {\n            writer.uint32(66).string(message.eventStageName);\n        }\n        if (message.activeSectionId !== 0) {\n            writer.uint32(72).uint32(message.activeSectionId);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseTournamentEvent();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.eventId = reader.int32();\n                    break;\n                case 2:\n                    message.eventTag = reader.string();\n                    break;\n                case 3:\n                    message.eventName = reader.string();\n                    break;\n                case 4:\n                    message.eventTimeStart = reader.uint32();\n                    break;\n                case 5:\n                    message.eventTimeEnd = reader.uint32();\n                    break;\n                case 6:\n                    message.eventPublic = reader.int32();\n                    break;\n                case 7:\n                    message.eventStageId = reader.int32();\n                    break;\n                case 8:\n                    message.eventStageName = reader.string();\n                    break;\n                case 9:\n                    message.activeSectionId = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j;\n        const message = createBaseTournamentEvent();\n        message.eventId = (_a = object.eventId) !== null && _a !== void 0 ? _a : 0;\n        message.eventTag = (_b = object.eventTag) !== null && _b !== void 0 ? _b : \"\";\n        message.eventName = (_c = object.eventName) !== null && _c !== void 0 ? _c : \"\";\n        message.eventTimeStart = (_d = object.eventTimeStart) !== null && _d !== void 0 ? _d : 0;\n        message.eventTimeEnd = (_e = object.eventTimeEnd) !== null && _e !== void 0 ? _e : 0;\n        message.eventPublic = (_f = object.eventPublic) !== null && _f !== void 0 ? _f : 0;\n        message.eventStageId = (_g = object.eventStageId) !== null && _g !== void 0 ? _g : 0;\n        message.eventStageName = (_h = object.eventStageName) !== null && _h !== void 0 ? _h : \"\";\n        message.activeSectionId = (_j = object.activeSectionId) !== null && _j !== void 0 ? _j : 0;\n        return message;\n    }\n};\nfunction createBaseGlobalStatistics() {\n    return {\n        playersOnline: 0,\n        serversOnline: 0,\n        playersSearching: 0,\n        serversAvailable: 0,\n        ongoingMatches: 0,\n        searchTimeAvg: 0,\n        searchStatistics: [],\n        mainPostUrl: \"\",\n        requiredAppidVersion: 0,\n        pricesheetVersion: 0,\n        twitchStreamsVersion: 0,\n        activeTournamentEventid: 0,\n        activeSurveyId: 0,\n        rtime32Cur: 0,\n        rtime32EventStart: 0\n    };\n}\nexports.GlobalStatistics = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.playersOnline !== 0) {\n            writer.uint32(8).uint32(message.playersOnline);\n        }\n        if (message.serversOnline !== 0) {\n            writer.uint32(16).uint32(message.serversOnline);\n        }\n        if (message.playersSearching !== 0) {\n            writer.uint32(24).uint32(message.playersSearching);\n        }\n        if (message.serversAvailable !== 0) {\n            writer.uint32(32).uint32(message.serversAvailable);\n        }\n        if (message.ongoingMatches !== 0) {\n            writer.uint32(40).uint32(message.ongoingMatches);\n        }\n        if (message.searchTimeAvg !== 0) {\n            writer.uint32(48).uint32(message.searchTimeAvg);\n        }\n        for (const v of message.searchStatistics) {\n            exports.DetailedSearchStatistic.encode(v, writer.uint32(58).fork()).ldelim();\n        }\n        if (message.mainPostUrl !== \"\") {\n            writer.uint32(66).string(message.mainPostUrl);\n        }\n        if (message.requiredAppidVersion !== 0) {\n            writer.uint32(72).uint32(message.requiredAppidVersion);\n        }\n        if (message.pricesheetVersion !== 0) {\n            writer.uint32(80).uint32(message.pricesheetVersion);\n        }\n        if (message.twitchStreamsVersion !== 0) {\n            writer.uint32(88).uint32(message.twitchStreamsVersion);\n        }\n        if (message.activeTournamentEventid !== 0) {\n            writer.uint32(96).uint32(message.activeTournamentEventid);\n        }\n        if (message.activeSurveyId !== 0) {\n            writer.uint32(104).uint32(message.activeSurveyId);\n        }\n        if (message.rtime32Cur !== 0) {\n            writer.uint32(112).uint32(message.rtime32Cur);\n        }\n        if (message.rtime32EventStart !== 0) {\n            writer.uint32(120).uint32(message.rtime32EventStart);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseGlobalStatistics();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.playersOnline = reader.uint32();\n                    break;\n                case 2:\n                    message.serversOnline = reader.uint32();\n                    break;\n                case 3:\n                    message.playersSearching = reader.uint32();\n                    break;\n                case 4:\n                    message.serversAvailable = reader.uint32();\n                    break;\n                case 5:\n                    message.ongoingMatches = reader.uint32();\n                    break;\n                case 6:\n                    message.searchTimeAvg = reader.uint32();\n                    break;\n                case 7:\n                    message.searchStatistics.push(exports.DetailedSearchStatistic.decode(reader, reader.uint32()));\n                    break;\n                case 8:\n                    message.mainPostUrl = reader.string();\n                    break;\n                case 9:\n                    message.requiredAppidVersion = reader.uint32();\n                    break;\n                case 10:\n                    message.pricesheetVersion = reader.uint32();\n                    break;\n                case 11:\n                    message.twitchStreamsVersion = reader.uint32();\n                    break;\n                case 12:\n                    message.activeTournamentEventid = reader.uint32();\n                    break;\n                case 13:\n                    message.activeSurveyId = reader.uint32();\n                    break;\n                case 14:\n                    message.rtime32Cur = reader.uint32();\n                    break;\n                case 15:\n                    message.rtime32EventStart = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;\n        const message = createBaseGlobalStatistics();\n        message.playersOnline = (_a = object.playersOnline) !== null && _a !== void 0 ? _a : 0;\n        message.serversOnline = (_b = object.serversOnline) !== null && _b !== void 0 ? _b : 0;\n        message.playersSearching = (_c = object.playersSearching) !== null && _c !== void 0 ? _c : 0;\n        message.serversAvailable = (_d = object.serversAvailable) !== null && _d !== void 0 ? _d : 0;\n        message.ongoingMatches = (_e = object.ongoingMatches) !== null && _e !== void 0 ? _e : 0;\n        message.searchTimeAvg = (_f = object.searchTimeAvg) !== null && _f !== void 0 ? _f : 0;\n        message.searchStatistics =\n            ((_g = object.searchStatistics) === null || _g === void 0 ? void 0 : _g.map(e => exports.DetailedSearchStatistic.fromPartial(e))) || [];\n        message.mainPostUrl = (_h = object.mainPostUrl) !== null && _h !== void 0 ? _h : \"\";\n        message.requiredAppidVersion = (_j = object.requiredAppidVersion) !== null && _j !== void 0 ? _j : 0;\n        message.pricesheetVersion = (_k = object.pricesheetVersion) !== null && _k !== void 0 ? _k : 0;\n        message.twitchStreamsVersion = (_l = object.twitchStreamsVersion) !== null && _l !== void 0 ? _l : 0;\n        message.activeTournamentEventid = (_m = object.activeTournamentEventid) !== null && _m !== void 0 ? _m : 0;\n        message.activeSurveyId = (_o = object.activeSurveyId) !== null && _o !== void 0 ? _o : 0;\n        message.rtime32Cur = (_p = object.rtime32Cur) !== null && _p !== void 0 ? _p : 0;\n        message.rtime32EventStart = (_q = object.rtime32EventStart) !== null && _q !== void 0 ? _q : 0;\n        return message;\n    }\n};\nfunction createBaseOperationalStatisticDescription() {\n    return { name: \"\", idkey: 0 };\n}\nexports.OperationalStatisticDescription = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.name !== \"\") {\n            writer.uint32(10).string(message.name);\n        }\n        if (message.idkey !== 0) {\n            writer.uint32(16).uint32(message.idkey);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseOperationalStatisticDescription();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.name = reader.string();\n                    break;\n                case 2:\n                    message.idkey = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseOperationalStatisticDescription();\n        message.name = (_a = object.name) !== null && _a !== void 0 ? _a : \"\";\n        message.idkey = (_b = object.idkey) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseOperationalStatisticElement() {\n    return { idkey: 0, values: [] };\n}\nexports.OperationalStatisticElement = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.idkey !== 0) {\n            writer.uint32(8).uint32(message.idkey);\n        }\n        writer.uint32(18).fork();\n        for (const v of message.values) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseOperationalStatisticElement();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.idkey = reader.uint32();\n                    break;\n                case 2:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.values.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.values.push(reader.int32());\n                    }\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseOperationalStatisticElement();\n        message.idkey = (_a = object.idkey) !== null && _a !== void 0 ? _a : 0;\n        message.values = ((_b = object.values) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];\n        return message;\n    }\n};\nfunction createBaseOperationalStatisticsPacket() {\n    return { packetid: 0, mstimestamp: 0, values: [] };\n}\nexports.OperationalStatisticsPacket = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.packetid !== 0) {\n            writer.uint32(8).int32(message.packetid);\n        }\n        if (message.mstimestamp !== 0) {\n            writer.uint32(16).int32(message.mstimestamp);\n        }\n        for (const v of message.values) {\n            exports.OperationalStatisticElement.encode(v, writer.uint32(26).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseOperationalStatisticsPacket();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.packetid = reader.int32();\n                    break;\n                case 2:\n                    message.mstimestamp = reader.int32();\n                    break;\n                case 3:\n                    message.values.push(exports.OperationalStatisticElement.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseOperationalStatisticsPacket();\n        message.packetid = (_a = object.packetid) !== null && _a !== void 0 ? _a : 0;\n        message.mstimestamp = (_b = object.mstimestamp) !== null && _b !== void 0 ? _b : 0;\n        message.values =\n            ((_c = object.values) === null || _c === void 0 ? void 0 : _c.map(e => exports.OperationalStatisticElement.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBasePlayerRankingInfo() {\n    return {\n        accountId: 0,\n        rankId: 0,\n        wins: 0,\n        rankChange: 0,\n        rankTypeId: 0,\n        tvControl: 0\n    };\n}\nexports.PlayerRankingInfo = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountId !== 0) {\n            writer.uint32(8).uint32(message.accountId);\n        }\n        if (message.rankId !== 0) {\n            writer.uint32(16).uint32(message.rankId);\n        }\n        if (message.wins !== 0) {\n            writer.uint32(24).uint32(message.wins);\n        }\n        if (message.rankChange !== 0) {\n            writer.uint32(37).float(message.rankChange);\n        }\n        if (message.rankTypeId !== 0) {\n            writer.uint32(48).uint32(message.rankTypeId);\n        }\n        if (message.tvControl !== 0) {\n            writer.uint32(56).uint32(message.tvControl);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBasePlayerRankingInfo();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountId = reader.uint32();\n                    break;\n                case 2:\n                    message.rankId = reader.uint32();\n                    break;\n                case 3:\n                    message.wins = reader.uint32();\n                    break;\n                case 4:\n                    message.rankChange = reader.float();\n                    break;\n                case 6:\n                    message.rankTypeId = reader.uint32();\n                    break;\n                case 7:\n                    message.tvControl = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f;\n        const message = createBasePlayerRankingInfo();\n        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;\n        message.rankId = (_b = object.rankId) !== null && _b !== void 0 ? _b : 0;\n        message.wins = (_c = object.wins) !== null && _c !== void 0 ? _c : 0;\n        message.rankChange = (_d = object.rankChange) !== null && _d !== void 0 ? _d : 0;\n        message.rankTypeId = (_e = object.rankTypeId) !== null && _e !== void 0 ? _e : 0;\n        message.tvControl = (_f = object.tvControl) !== null && _f !== void 0 ? _f : 0;\n        return message;\n    }\n};\nfunction createBasePlayerCommendationInfo() {\n    return { cmdFriendly: 0, cmdTeaching: 0, cmdLeader: 0 };\n}\nexports.PlayerCommendationInfo = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.cmdFriendly !== 0) {\n            writer.uint32(8).uint32(message.cmdFriendly);\n        }\n        if (message.cmdTeaching !== 0) {\n            writer.uint32(16).uint32(message.cmdTeaching);\n        }\n        if (message.cmdLeader !== 0) {\n            writer.uint32(32).uint32(message.cmdLeader);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBasePlayerCommendationInfo();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.cmdFriendly = reader.uint32();\n                    break;\n                case 2:\n                    message.cmdTeaching = reader.uint32();\n                    break;\n                case 4:\n                    message.cmdLeader = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBasePlayerCommendationInfo();\n        message.cmdFriendly = (_a = object.cmdFriendly) !== null && _a !== void 0 ? _a : 0;\n        message.cmdTeaching = (_b = object.cmdTeaching) !== null && _b !== void 0 ? _b : 0;\n        message.cmdLeader = (_c = object.cmdLeader) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBasePlayerMedalsInfo() {\n    return { displayItemsDefidx: [], featuredDisplayItemDefidx: 0 };\n}\nexports.PlayerMedalsInfo = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        writer.uint32(58).fork();\n        for (const v of message.displayItemsDefidx) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        if (message.featuredDisplayItemDefidx !== 0) {\n            writer.uint32(64).uint32(message.featuredDisplayItemDefidx);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBasePlayerMedalsInfo();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 7:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.displayItemsDefidx.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.displayItemsDefidx.push(reader.uint32());\n                    }\n                    break;\n                case 8:\n                    message.featuredDisplayItemDefidx = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBasePlayerMedalsInfo();\n        message.displayItemsDefidx = ((_a = object.displayItemsDefidx) === null || _a === void 0 ? void 0 : _a.map(e => e)) || [];\n        message.featuredDisplayItemDefidx = (_b = object.featuredDisplayItemDefidx) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseAccountActivity() {\n    return { activity: 0, mode: 0, map: 0, matchid: Long.UZERO };\n}\nexports.AccountActivity = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.activity !== 0) {\n            writer.uint32(8).uint32(message.activity);\n        }\n        if (message.mode !== 0) {\n            writer.uint32(16).uint32(message.mode);\n        }\n        if (message.map !== 0) {\n            writer.uint32(24).uint32(message.map);\n        }\n        if (!message.matchid.isZero()) {\n            writer.uint32(32).uint64(message.matchid);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseAccountActivity();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.activity = reader.uint32();\n                    break;\n                case 2:\n                    message.mode = reader.uint32();\n                    break;\n                case 3:\n                    message.map = reader.uint32();\n                    break;\n                case 4:\n                    message.matchid = reader.uint64();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseAccountActivity();\n        message.activity = (_a = object.activity) !== null && _a !== void 0 ? _a : 0;\n        message.mode = (_b = object.mode) !== null && _b !== void 0 ? _b : 0;\n        message.map = (_c = object.map) !== null && _c !== void 0 ? _c : 0;\n        message.matchid =\n            object.matchid !== undefined && object.matchid !== null\n                ? Long.fromValue(object.matchid)\n                : Long.UZERO;\n        return message;\n    }\n};\nfunction createBaseTournamentMatchSetup() {\n    return { eventId: 0, teamIdCt: 0, teamIdT: 0, eventStageId: 0 };\n}\nexports.TournamentMatchSetup = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.eventId !== 0) {\n            writer.uint32(8).int32(message.eventId);\n        }\n        if (message.teamIdCt !== 0) {\n            writer.uint32(16).int32(message.teamIdCt);\n        }\n        if (message.teamIdT !== 0) {\n            writer.uint32(24).int32(message.teamIdT);\n        }\n        if (message.eventStageId !== 0) {\n            writer.uint32(32).int32(message.eventStageId);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseTournamentMatchSetup();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.eventId = reader.int32();\n                    break;\n                case 2:\n                    message.teamIdCt = reader.int32();\n                    break;\n                case 3:\n                    message.teamIdT = reader.int32();\n                    break;\n                case 4:\n                    message.eventStageId = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseTournamentMatchSetup();\n        message.eventId = (_a = object.eventId) !== null && _a !== void 0 ? _a : 0;\n        message.teamIdCt = (_b = object.teamIdCt) !== null && _b !== void 0 ? _b : 0;\n        message.teamIdT = (_c = object.teamIdT) !== null && _c !== void 0 ? _c : 0;\n        message.eventStageId = (_d = object.eventStageId) !== null && _d !== void 0 ? _d : 0;\n        return message;\n    }\n};\nfunction createBaseServerHltvInfo() {\n    return {\n        tvUdpPort: 0,\n        tvWatchKey: Long.UZERO,\n        tvSlots: 0,\n        tvClients: 0,\n        tvProxies: 0,\n        tvTime: 0,\n        gameType: 0,\n        gameMapgroup: \"\",\n        gameMap: \"\",\n        tvMasterSteamid: Long.UZERO,\n        tvLocalSlots: 0,\n        tvLocalClients: 0,\n        tvLocalProxies: 0,\n        tvRelaySlots: 0,\n        tvRelayClients: 0,\n        tvRelayProxies: 0,\n        tvRelayAddress: 0,\n        tvRelayPort: 0,\n        tvRelaySteamid: Long.UZERO,\n        flags: 0\n    };\n}\nexports.ServerHltvInfo = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.tvUdpPort !== 0) {\n            writer.uint32(8).uint32(message.tvUdpPort);\n        }\n        if (!message.tvWatchKey.isZero()) {\n            writer.uint32(16).uint64(message.tvWatchKey);\n        }\n        if (message.tvSlots !== 0) {\n            writer.uint32(24).uint32(message.tvSlots);\n        }\n        if (message.tvClients !== 0) {\n            writer.uint32(32).uint32(message.tvClients);\n        }\n        if (message.tvProxies !== 0) {\n            writer.uint32(40).uint32(message.tvProxies);\n        }\n        if (message.tvTime !== 0) {\n            writer.uint32(48).uint32(message.tvTime);\n        }\n        if (message.gameType !== 0) {\n            writer.uint32(64).uint32(message.gameType);\n        }\n        if (message.gameMapgroup !== \"\") {\n            writer.uint32(74).string(message.gameMapgroup);\n        }\n        if (message.gameMap !== \"\") {\n            writer.uint32(82).string(message.gameMap);\n        }\n        if (!message.tvMasterSteamid.isZero()) {\n            writer.uint32(88).uint64(message.tvMasterSteamid);\n        }\n        if (message.tvLocalSlots !== 0) {\n            writer.uint32(96).uint32(message.tvLocalSlots);\n        }\n        if (message.tvLocalClients !== 0) {\n            writer.uint32(104).uint32(message.tvLocalClients);\n        }\n        if (message.tvLocalProxies !== 0) {\n            writer.uint32(112).uint32(message.tvLocalProxies);\n        }\n        if (message.tvRelaySlots !== 0) {\n            writer.uint32(120).uint32(message.tvRelaySlots);\n        }\n        if (message.tvRelayClients !== 0) {\n            writer.uint32(128).uint32(message.tvRelayClients);\n        }\n        if (message.tvRelayProxies !== 0) {\n            writer.uint32(136).uint32(message.tvRelayProxies);\n        }\n        if (message.tvRelayAddress !== 0) {\n            writer.uint32(144).uint32(message.tvRelayAddress);\n        }\n        if (message.tvRelayPort !== 0) {\n            writer.uint32(152).uint32(message.tvRelayPort);\n        }\n        if (!message.tvRelaySteamid.isZero()) {\n            writer.uint32(160).uint64(message.tvRelaySteamid);\n        }\n        if (message.flags !== 0) {\n            writer.uint32(168).uint32(message.flags);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseServerHltvInfo();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.tvUdpPort = reader.uint32();\n                    break;\n                case 2:\n                    message.tvWatchKey = reader.uint64();\n                    break;\n                case 3:\n                    message.tvSlots = reader.uint32();\n                    break;\n                case 4:\n                    message.tvClients = reader.uint32();\n                    break;\n                case 5:\n                    message.tvProxies = reader.uint32();\n                    break;\n                case 6:\n                    message.tvTime = reader.uint32();\n                    break;\n                case 8:\n                    message.gameType = reader.uint32();\n                    break;\n                case 9:\n                    message.gameMapgroup = reader.string();\n                    break;\n                case 10:\n                    message.gameMap = reader.string();\n                    break;\n                case 11:\n                    message.tvMasterSteamid = reader.uint64();\n                    break;\n                case 12:\n                    message.tvLocalSlots = reader.uint32();\n                    break;\n                case 13:\n                    message.tvLocalClients = reader.uint32();\n                    break;\n                case 14:\n                    message.tvLocalProxies = reader.uint32();\n                    break;\n                case 15:\n                    message.tvRelaySlots = reader.uint32();\n                    break;\n                case 16:\n                    message.tvRelayClients = reader.uint32();\n                    break;\n                case 17:\n                    message.tvRelayProxies = reader.uint32();\n                    break;\n                case 18:\n                    message.tvRelayAddress = reader.uint32();\n                    break;\n                case 19:\n                    message.tvRelayPort = reader.uint32();\n                    break;\n                case 20:\n                    message.tvRelaySteamid = reader.uint64();\n                    break;\n                case 21:\n                    message.flags = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;\n        const message = createBaseServerHltvInfo();\n        message.tvUdpPort = (_a = object.tvUdpPort) !== null && _a !== void 0 ? _a : 0;\n        message.tvWatchKey =\n            object.tvWatchKey !== undefined && object.tvWatchKey !== null\n                ? Long.fromValue(object.tvWatchKey)\n                : Long.UZERO;\n        message.tvSlots = (_b = object.tvSlots) !== null && _b !== void 0 ? _b : 0;\n        message.tvClients = (_c = object.tvClients) !== null && _c !== void 0 ? _c : 0;\n        message.tvProxies = (_d = object.tvProxies) !== null && _d !== void 0 ? _d : 0;\n        message.tvTime = (_e = object.tvTime) !== null && _e !== void 0 ? _e : 0;\n        message.gameType = (_f = object.gameType) !== null && _f !== void 0 ? _f : 0;\n        message.gameMapgroup = (_g = object.gameMapgroup) !== null && _g !== void 0 ? _g : \"\";\n        message.gameMap = (_h = object.gameMap) !== null && _h !== void 0 ? _h : \"\";\n        message.tvMasterSteamid =\n            object.tvMasterSteamid !== undefined && object.tvMasterSteamid !== null\n                ? Long.fromValue(object.tvMasterSteamid)\n                : Long.UZERO;\n        message.tvLocalSlots = (_j = object.tvLocalSlots) !== null && _j !== void 0 ? _j : 0;\n        message.tvLocalClients = (_k = object.tvLocalClients) !== null && _k !== void 0 ? _k : 0;\n        message.tvLocalProxies = (_l = object.tvLocalProxies) !== null && _l !== void 0 ? _l : 0;\n        message.tvRelaySlots = (_m = object.tvRelaySlots) !== null && _m !== void 0 ? _m : 0;\n        message.tvRelayClients = (_o = object.tvRelayClients) !== null && _o !== void 0 ? _o : 0;\n        message.tvRelayProxies = (_p = object.tvRelayProxies) !== null && _p !== void 0 ? _p : 0;\n        message.tvRelayAddress = (_q = object.tvRelayAddress) !== null && _q !== void 0 ? _q : 0;\n        message.tvRelayPort = (_r = object.tvRelayPort) !== null && _r !== void 0 ? _r : 0;\n        message.tvRelaySteamid =\n            object.tvRelaySteamid !== undefined && object.tvRelaySteamid !== null\n                ? Long.fromValue(object.tvRelaySteamid)\n                : Long.UZERO;\n        message.flags = (_s = object.flags) !== null && _s !== void 0 ? _s : 0;\n        return message;\n    }\n};\nfunction createBaseIpAddressMask() {\n    return { a: 0, b: 0, c: 0, d: 0, bits: 0, token: 0 };\n}\nexports.IpAddressMask = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.a !== 0) {\n            writer.uint32(8).uint32(message.a);\n        }\n        if (message.b !== 0) {\n            writer.uint32(16).uint32(message.b);\n        }\n        if (message.c !== 0) {\n            writer.uint32(24).uint32(message.c);\n        }\n        if (message.d !== 0) {\n            writer.uint32(32).uint32(message.d);\n        }\n        if (message.bits !== 0) {\n            writer.uint32(40).uint32(message.bits);\n        }\n        if (message.token !== 0) {\n            writer.uint32(48).uint32(message.token);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseIpAddressMask();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.a = reader.uint32();\n                    break;\n                case 2:\n                    message.b = reader.uint32();\n                    break;\n                case 3:\n                    message.c = reader.uint32();\n                    break;\n                case 4:\n                    message.d = reader.uint32();\n                    break;\n                case 5:\n                    message.bits = reader.uint32();\n                    break;\n                case 6:\n                    message.token = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f;\n        const message = createBaseIpAddressMask();\n        message.a = (_a = object.a) !== null && _a !== void 0 ? _a : 0;\n        message.b = (_b = object.b) !== null && _b !== void 0 ? _b : 0;\n        message.c = (_c = object.c) !== null && _c !== void 0 ? _c : 0;\n        message.d = (_d = object.d) !== null && _d !== void 0 ? _d : 0;\n        message.bits = (_e = object.bits) !== null && _e !== void 0 ? _e : 0;\n        message.token = (_f = object.token) !== null && _f !== void 0 ? _f : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgCsgoSteamUserStatChange() {\n    return { ecsgosteamuserstat: 0, delta: 0, absolute: false };\n}\nexports.CMsgCsgoSteamUserStatChange = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.ecsgosteamuserstat !== 0) {\n            writer.uint32(8).int32(message.ecsgosteamuserstat);\n        }\n        if (message.delta !== 0) {\n            writer.uint32(16).int32(message.delta);\n        }\n        if (message.absolute === true) {\n            writer.uint32(24).bool(message.absolute);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgCsgoSteamUserStatChange();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.ecsgosteamuserstat = reader.int32();\n                    break;\n                case 2:\n                    message.delta = reader.int32();\n                    break;\n                case 3:\n                    message.absolute = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCMsgCsgoSteamUserStatChange();\n        message.ecsgosteamuserstat = (_a = object.ecsgosteamuserstat) !== null && _a !== void 0 ? _a : 0;\n        message.delta = (_b = object.delta) !== null && _b !== void 0 ? _b : 0;\n        message.absolute = (_c = object.absolute) !== null && _c !== void 0 ? _c : false;\n        return message;\n    }\n};\nfunction createBaseXpProgressData() {\n    return { xpPoints: 0, xpCategory: 0 };\n}\nexports.XpProgressData = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.xpPoints !== 0) {\n            writer.uint32(8).uint32(message.xpPoints);\n        }\n        if (message.xpCategory !== 0) {\n            writer.uint32(16).int32(message.xpCategory);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseXpProgressData();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.xpPoints = reader.uint32();\n                    break;\n                case 2:\n                    message.xpCategory = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseXpProgressData();\n        message.xpPoints = (_a = object.xpPoints) !== null && _a !== void 0 ? _a : 0;\n        message.xpCategory = (_b = object.xpCategory) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseMatchEndItemUpdates() {\n    return { itemId: Long.UZERO, itemAttrDefidx: 0, itemAttrDeltaValue: 0 };\n}\nexports.MatchEndItemUpdates = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.itemId.isZero()) {\n            writer.uint32(8).uint64(message.itemId);\n        }\n        if (message.itemAttrDefidx !== 0) {\n            writer.uint32(16).uint32(message.itemAttrDefidx);\n        }\n        if (message.itemAttrDeltaValue !== 0) {\n            writer.uint32(24).uint32(message.itemAttrDeltaValue);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseMatchEndItemUpdates();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.itemId = reader.uint64();\n                    break;\n                case 2:\n                    message.itemAttrDefidx = reader.uint32();\n                    break;\n                case 3:\n                    message.itemAttrDeltaValue = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseMatchEndItemUpdates();\n        message.itemId =\n            object.itemId !== undefined && object.itemId !== null\n                ? Long.fromValue(object.itemId)\n                : Long.UZERO;\n        message.itemAttrDefidx = (_a = object.itemAttrDefidx) !== null && _a !== void 0 ? _a : 0;\n        message.itemAttrDeltaValue = (_b = object.itemAttrDeltaValue) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseScoreLeaderboardData() {\n    return {\n        questId: Long.UZERO,\n        score: 0,\n        accountentries: [],\n        matchentries: []\n    };\n}\nexports.ScoreLeaderboardData = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.questId.isZero()) {\n            writer.uint32(8).uint64(message.questId);\n        }\n        if (message.score !== 0) {\n            writer.uint32(16).uint32(message.score);\n        }\n        for (const v of message.accountentries) {\n            exports.ScoreLeaderboardData_AccountEntries.encode(v, writer.uint32(26).fork()).ldelim();\n        }\n        for (const v of message.matchentries) {\n            exports.ScoreLeaderboardData_Entry.encode(v, writer.uint32(42).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseScoreLeaderboardData();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.questId = reader.uint64();\n                    break;\n                case 2:\n                    message.score = reader.uint32();\n                    break;\n                case 3:\n                    message.accountentries.push(exports.ScoreLeaderboardData_AccountEntries.decode(reader, reader.uint32()));\n                    break;\n                case 5:\n                    message.matchentries.push(exports.ScoreLeaderboardData_Entry.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseScoreLeaderboardData();\n        message.questId =\n            object.questId !== undefined && object.questId !== null\n                ? Long.fromValue(object.questId)\n                : Long.UZERO;\n        message.score = (_a = object.score) !== null && _a !== void 0 ? _a : 0;\n        message.accountentries =\n            ((_b = object.accountentries) === null || _b === void 0 ? void 0 : _b.map(e => exports.ScoreLeaderboardData_AccountEntries.fromPartial(e))) || [];\n        message.matchentries =\n            ((_c = object.matchentries) === null || _c === void 0 ? void 0 : _c.map(e => exports.ScoreLeaderboardData_Entry.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseScoreLeaderboardData_Entry() {\n    return { tag: 0, val: 0 };\n}\nexports.ScoreLeaderboardData_Entry = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.tag !== 0) {\n            writer.uint32(8).uint32(message.tag);\n        }\n        if (message.val !== 0) {\n            writer.uint32(16).uint32(message.val);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseScoreLeaderboardData_Entry();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.tag = reader.uint32();\n                    break;\n                case 2:\n                    message.val = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseScoreLeaderboardData_Entry();\n        message.tag = (_a = object.tag) !== null && _a !== void 0 ? _a : 0;\n        message.val = (_b = object.val) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseScoreLeaderboardData_AccountEntries() {\n    return { accountid: 0, entries: [] };\n}\nexports.ScoreLeaderboardData_AccountEntries = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountid !== 0) {\n            writer.uint32(8).uint32(message.accountid);\n        }\n        for (const v of message.entries) {\n            exports.ScoreLeaderboardData_Entry.encode(v, writer.uint32(18).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseScoreLeaderboardData_AccountEntries();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountid = reader.uint32();\n                    break;\n                case 2:\n                    message.entries.push(exports.ScoreLeaderboardData_Entry.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseScoreLeaderboardData_AccountEntries();\n        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;\n        message.entries =\n            ((_b = object.entries) === null || _b === void 0 ? void 0 : _b.map(e => exports.ScoreLeaderboardData_Entry.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBasePlayerQuestData() {\n    return {\n        questerAccountId: 0,\n        questItemData: [],\n        xpProgressData: [],\n        timePlayed: 0,\n        mmGameMode: 0,\n        itemUpdates: [],\n        operationPointsEligible: false,\n        userstatchanges: []\n    };\n}\nexports.PlayerQuestData = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.questerAccountId !== 0) {\n            writer.uint32(8).uint32(message.questerAccountId);\n        }\n        for (const v of message.questItemData) {\n            exports.PlayerQuestData_QuestItemData.encode(v, writer.uint32(18).fork()).ldelim();\n        }\n        for (const v of message.xpProgressData) {\n            exports.XpProgressData.encode(v, writer.uint32(26).fork()).ldelim();\n        }\n        if (message.timePlayed !== 0) {\n            writer.uint32(32).uint32(message.timePlayed);\n        }\n        if (message.mmGameMode !== 0) {\n            writer.uint32(40).uint32(message.mmGameMode);\n        }\n        for (const v of message.itemUpdates) {\n            exports.MatchEndItemUpdates.encode(v, writer.uint32(50).fork()).ldelim();\n        }\n        if (message.operationPointsEligible === true) {\n            writer.uint32(56).bool(message.operationPointsEligible);\n        }\n        for (const v of message.userstatchanges) {\n            exports.CMsgCsgoSteamUserStatChange.encode(v, writer.uint32(66).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBasePlayerQuestData();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.questerAccountId = reader.uint32();\n                    break;\n                case 2:\n                    message.questItemData.push(exports.PlayerQuestData_QuestItemData.decode(reader, reader.uint32()));\n                    break;\n                case 3:\n                    message.xpProgressData.push(exports.XpProgressData.decode(reader, reader.uint32()));\n                    break;\n                case 4:\n                    message.timePlayed = reader.uint32();\n                    break;\n                case 5:\n                    message.mmGameMode = reader.uint32();\n                    break;\n                case 6:\n                    message.itemUpdates.push(exports.MatchEndItemUpdates.decode(reader, reader.uint32()));\n                    break;\n                case 7:\n                    message.operationPointsEligible = reader.bool();\n                    break;\n                case 8:\n                    message.userstatchanges.push(exports.CMsgCsgoSteamUserStatChange.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h;\n        const message = createBasePlayerQuestData();\n        message.questerAccountId = (_a = object.questerAccountId) !== null && _a !== void 0 ? _a : 0;\n        message.questItemData =\n            ((_b = object.questItemData) === null || _b === void 0 ? void 0 : _b.map(e => exports.PlayerQuestData_QuestItemData.fromPartial(e))) || [];\n        message.xpProgressData =\n            ((_c = object.xpProgressData) === null || _c === void 0 ? void 0 : _c.map(e => exports.XpProgressData.fromPartial(e))) || [];\n        message.timePlayed = (_d = object.timePlayed) !== null && _d !== void 0 ? _d : 0;\n        message.mmGameMode = (_e = object.mmGameMode) !== null && _e !== void 0 ? _e : 0;\n        message.itemUpdates =\n            ((_f = object.itemUpdates) === null || _f === void 0 ? void 0 : _f.map(e => exports.MatchEndItemUpdates.fromPartial(e))) || [];\n        message.operationPointsEligible = (_g = object.operationPointsEligible) !== null && _g !== void 0 ? _g : false;\n        message.userstatchanges =\n            ((_h = object.userstatchanges) === null || _h === void 0 ? void 0 : _h.map(e => exports.CMsgCsgoSteamUserStatChange.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBasePlayerQuestData_QuestItemData() {\n    return {\n        questId: Long.UZERO,\n        questNormalPointsEarned: 0,\n        questBonusPointsEarned: 0\n    };\n}\nexports.PlayerQuestData_QuestItemData = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.questId.isZero()) {\n            writer.uint32(8).uint64(message.questId);\n        }\n        if (message.questNormalPointsEarned !== 0) {\n            writer.uint32(16).int32(message.questNormalPointsEarned);\n        }\n        if (message.questBonusPointsEarned !== 0) {\n            writer.uint32(24).int32(message.questBonusPointsEarned);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBasePlayerQuestData_QuestItemData();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.questId = reader.uint64();\n                    break;\n                case 2:\n                    message.questNormalPointsEarned = reader.int32();\n                    break;\n                case 3:\n                    message.questBonusPointsEarned = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBasePlayerQuestData_QuestItemData();\n        message.questId =\n            object.questId !== undefined && object.questId !== null\n                ? Long.fromValue(object.questId)\n                : Long.UZERO;\n        message.questNormalPointsEarned = (_a = object.questNormalPointsEarned) !== null && _a !== void 0 ? _a : 0;\n        message.questBonusPointsEarned = (_b = object.questBonusPointsEarned) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseDeepPlayerStatsEntry() {\n    return {\n        accountid: 0,\n        matchId: Long.UZERO,\n        mmGameMode: 0,\n        mapid: 0,\n        bStartingCt: false,\n        matchOutcome: 0,\n        roundsWon: 0,\n        roundsLost: 0,\n        statScore: 0,\n        statDeaths: 0,\n        statMvps: 0,\n        enemyKills: 0,\n        enemyHeadshots: 0,\n        enemy2ks: 0,\n        enemy3ks: 0,\n        enemy4ks: 0,\n        totalDamage: 0,\n        engagementsEntryCount: 0,\n        engagementsEntryWins: 0,\n        engagements1v1Count: 0,\n        engagements1v1Wins: 0,\n        engagements1v2Count: 0,\n        engagements1v2Wins: 0,\n        utilityCount: 0,\n        utilitySuccess: 0,\n        flashCount: 0,\n        flashSuccess: 0,\n        mates: []\n    };\n}\nexports.DeepPlayerStatsEntry = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountid !== 0) {\n            writer.uint32(8).uint32(message.accountid);\n        }\n        if (!message.matchId.isZero()) {\n            writer.uint32(16).uint64(message.matchId);\n        }\n        if (message.mmGameMode !== 0) {\n            writer.uint32(24).uint32(message.mmGameMode);\n        }\n        if (message.mapid !== 0) {\n            writer.uint32(32).uint32(message.mapid);\n        }\n        if (message.bStartingCt === true) {\n            writer.uint32(40).bool(message.bStartingCt);\n        }\n        if (message.matchOutcome !== 0) {\n            writer.uint32(48).uint32(message.matchOutcome);\n        }\n        if (message.roundsWon !== 0) {\n            writer.uint32(56).uint32(message.roundsWon);\n        }\n        if (message.roundsLost !== 0) {\n            writer.uint32(64).uint32(message.roundsLost);\n        }\n        if (message.statScore !== 0) {\n            writer.uint32(72).uint32(message.statScore);\n        }\n        if (message.statDeaths !== 0) {\n            writer.uint32(96).uint32(message.statDeaths);\n        }\n        if (message.statMvps !== 0) {\n            writer.uint32(104).uint32(message.statMvps);\n        }\n        if (message.enemyKills !== 0) {\n            writer.uint32(112).uint32(message.enemyKills);\n        }\n        if (message.enemyHeadshots !== 0) {\n            writer.uint32(120).uint32(message.enemyHeadshots);\n        }\n        if (message.enemy2ks !== 0) {\n            writer.uint32(128).uint32(message.enemy2ks);\n        }\n        if (message.enemy3ks !== 0) {\n            writer.uint32(136).uint32(message.enemy3ks);\n        }\n        if (message.enemy4ks !== 0) {\n            writer.uint32(144).uint32(message.enemy4ks);\n        }\n        if (message.totalDamage !== 0) {\n            writer.uint32(152).uint32(message.totalDamage);\n        }\n        if (message.engagementsEntryCount !== 0) {\n            writer.uint32(184).uint32(message.engagementsEntryCount);\n        }\n        if (message.engagementsEntryWins !== 0) {\n            writer.uint32(192).uint32(message.engagementsEntryWins);\n        }\n        if (message.engagements1v1Count !== 0) {\n            writer.uint32(200).uint32(message.engagements1v1Count);\n        }\n        if (message.engagements1v1Wins !== 0) {\n            writer.uint32(208).uint32(message.engagements1v1Wins);\n        }\n        if (message.engagements1v2Count !== 0) {\n            writer.uint32(216).uint32(message.engagements1v2Count);\n        }\n        if (message.engagements1v2Wins !== 0) {\n            writer.uint32(224).uint32(message.engagements1v2Wins);\n        }\n        if (message.utilityCount !== 0) {\n            writer.uint32(232).uint32(message.utilityCount);\n        }\n        if (message.utilitySuccess !== 0) {\n            writer.uint32(240).uint32(message.utilitySuccess);\n        }\n        if (message.flashCount !== 0) {\n            writer.uint32(256).uint32(message.flashCount);\n        }\n        if (message.flashSuccess !== 0) {\n            writer.uint32(264).uint32(message.flashSuccess);\n        }\n        writer.uint32(274).fork();\n        for (const v of message.mates) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseDeepPlayerStatsEntry();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountid = reader.uint32();\n                    break;\n                case 2:\n                    message.matchId = reader.uint64();\n                    break;\n                case 3:\n                    message.mmGameMode = reader.uint32();\n                    break;\n                case 4:\n                    message.mapid = reader.uint32();\n                    break;\n                case 5:\n                    message.bStartingCt = reader.bool();\n                    break;\n                case 6:\n                    message.matchOutcome = reader.uint32();\n                    break;\n                case 7:\n                    message.roundsWon = reader.uint32();\n                    break;\n                case 8:\n                    message.roundsLost = reader.uint32();\n                    break;\n                case 9:\n                    message.statScore = reader.uint32();\n                    break;\n                case 12:\n                    message.statDeaths = reader.uint32();\n                    break;\n                case 13:\n                    message.statMvps = reader.uint32();\n                    break;\n                case 14:\n                    message.enemyKills = reader.uint32();\n                    break;\n                case 15:\n                    message.enemyHeadshots = reader.uint32();\n                    break;\n                case 16:\n                    message.enemy2ks = reader.uint32();\n                    break;\n                case 17:\n                    message.enemy3ks = reader.uint32();\n                    break;\n                case 18:\n                    message.enemy4ks = reader.uint32();\n                    break;\n                case 19:\n                    message.totalDamage = reader.uint32();\n                    break;\n                case 23:\n                    message.engagementsEntryCount = reader.uint32();\n                    break;\n                case 24:\n                    message.engagementsEntryWins = reader.uint32();\n                    break;\n                case 25:\n                    message.engagements1v1Count = reader.uint32();\n                    break;\n                case 26:\n                    message.engagements1v1Wins = reader.uint32();\n                    break;\n                case 27:\n                    message.engagements1v2Count = reader.uint32();\n                    break;\n                case 28:\n                    message.engagements1v2Wins = reader.uint32();\n                    break;\n                case 29:\n                    message.utilityCount = reader.uint32();\n                    break;\n                case 30:\n                    message.utilitySuccess = reader.uint32();\n                    break;\n                case 32:\n                    message.flashCount = reader.uint32();\n                    break;\n                case 33:\n                    message.flashSuccess = reader.uint32();\n                    break;\n                case 34:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.mates.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.mates.push(reader.uint32());\n                    }\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2;\n        const message = createBaseDeepPlayerStatsEntry();\n        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;\n        message.matchId =\n            object.matchId !== undefined && object.matchId !== null\n                ? Long.fromValue(object.matchId)\n                : Long.UZERO;\n        message.mmGameMode = (_b = object.mmGameMode) !== null && _b !== void 0 ? _b : 0;\n        message.mapid = (_c = object.mapid) !== null && _c !== void 0 ? _c : 0;\n        message.bStartingCt = (_d = object.bStartingCt) !== null && _d !== void 0 ? _d : false;\n        message.matchOutcome = (_e = object.matchOutcome) !== null && _e !== void 0 ? _e : 0;\n        message.roundsWon = (_f = object.roundsWon) !== null && _f !== void 0 ? _f : 0;\n        message.roundsLost = (_g = object.roundsLost) !== null && _g !== void 0 ? _g : 0;\n        message.statScore = (_h = object.statScore) !== null && _h !== void 0 ? _h : 0;\n        message.statDeaths = (_j = object.statDeaths) !== null && _j !== void 0 ? _j : 0;\n        message.statMvps = (_k = object.statMvps) !== null && _k !== void 0 ? _k : 0;\n        message.enemyKills = (_l = object.enemyKills) !== null && _l !== void 0 ? _l : 0;\n        message.enemyHeadshots = (_m = object.enemyHeadshots) !== null && _m !== void 0 ? _m : 0;\n        message.enemy2ks = (_o = object.enemy2ks) !== null && _o !== void 0 ? _o : 0;\n        message.enemy3ks = (_p = object.enemy3ks) !== null && _p !== void 0 ? _p : 0;\n        message.enemy4ks = (_q = object.enemy4ks) !== null && _q !== void 0 ? _q : 0;\n        message.totalDamage = (_r = object.totalDamage) !== null && _r !== void 0 ? _r : 0;\n        message.engagementsEntryCount = (_s = object.engagementsEntryCount) !== null && _s !== void 0 ? _s : 0;\n        message.engagementsEntryWins = (_t = object.engagementsEntryWins) !== null && _t !== void 0 ? _t : 0;\n        message.engagements1v1Count = (_u = object.engagements1v1Count) !== null && _u !== void 0 ? _u : 0;\n        message.engagements1v1Wins = (_v = object.engagements1v1Wins) !== null && _v !== void 0 ? _v : 0;\n        message.engagements1v2Count = (_w = object.engagements1v2Count) !== null && _w !== void 0 ? _w : 0;\n        message.engagements1v2Wins = (_x = object.engagements1v2Wins) !== null && _x !== void 0 ? _x : 0;\n        message.utilityCount = (_y = object.utilityCount) !== null && _y !== void 0 ? _y : 0;\n        message.utilitySuccess = (_z = object.utilitySuccess) !== null && _z !== void 0 ? _z : 0;\n        message.flashCount = (_0 = object.flashCount) !== null && _0 !== void 0 ? _0 : 0;\n        message.flashSuccess = (_1 = object.flashSuccess) !== null && _1 !== void 0 ? _1 : 0;\n        message.mates = ((_2 = object.mates) === null || _2 === void 0 ? void 0 : _2.map(e => e)) || [];\n        return message;\n    }\n};\nfunction createBaseDeepPlayerMatchEvent() {\n    return {\n        accountid: 0,\n        matchId: Long.UZERO,\n        eventId: 0,\n        eventType: 0,\n        bPlayingCt: false,\n        userPosX: 0,\n        userPosY: 0,\n        userPosZ: 0,\n        userDefidx: 0,\n        otherPosX: 0,\n        otherPosY: 0,\n        otherPosZ: 0,\n        otherDefidx: 0,\n        eventData: 0\n    };\n}\nexports.DeepPlayerMatchEvent = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountid !== 0) {\n            writer.uint32(8).uint32(message.accountid);\n        }\n        if (!message.matchId.isZero()) {\n            writer.uint32(16).uint64(message.matchId);\n        }\n        if (message.eventId !== 0) {\n            writer.uint32(24).uint32(message.eventId);\n        }\n        if (message.eventType !== 0) {\n            writer.uint32(32).uint32(message.eventType);\n        }\n        if (message.bPlayingCt === true) {\n            writer.uint32(40).bool(message.bPlayingCt);\n        }\n        if (message.userPosX !== 0) {\n            writer.uint32(48).int32(message.userPosX);\n        }\n        if (message.userPosY !== 0) {\n            writer.uint32(56).int32(message.userPosY);\n        }\n        if (message.userPosZ !== 0) {\n            writer.uint32(96).int32(message.userPosZ);\n        }\n        if (message.userDefidx !== 0) {\n            writer.uint32(64).uint32(message.userDefidx);\n        }\n        if (message.otherPosX !== 0) {\n            writer.uint32(72).int32(message.otherPosX);\n        }\n        if (message.otherPosY !== 0) {\n            writer.uint32(80).int32(message.otherPosY);\n        }\n        if (message.otherPosZ !== 0) {\n            writer.uint32(104).int32(message.otherPosZ);\n        }\n        if (message.otherDefidx !== 0) {\n            writer.uint32(88).uint32(message.otherDefidx);\n        }\n        if (message.eventData !== 0) {\n            writer.uint32(112).int32(message.eventData);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseDeepPlayerMatchEvent();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountid = reader.uint32();\n                    break;\n                case 2:\n                    message.matchId = reader.uint64();\n                    break;\n                case 3:\n                    message.eventId = reader.uint32();\n                    break;\n                case 4:\n                    message.eventType = reader.uint32();\n                    break;\n                case 5:\n                    message.bPlayingCt = reader.bool();\n                    break;\n                case 6:\n                    message.userPosX = reader.int32();\n                    break;\n                case 7:\n                    message.userPosY = reader.int32();\n                    break;\n                case 12:\n                    message.userPosZ = reader.int32();\n                    break;\n                case 8:\n                    message.userDefidx = reader.uint32();\n                    break;\n                case 9:\n                    message.otherPosX = reader.int32();\n                    break;\n                case 10:\n                    message.otherPosY = reader.int32();\n                    break;\n                case 13:\n                    message.otherPosZ = reader.int32();\n                    break;\n                case 11:\n                    message.otherDefidx = reader.uint32();\n                    break;\n                case 14:\n                    message.eventData = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;\n        const message = createBaseDeepPlayerMatchEvent();\n        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;\n        message.matchId =\n            object.matchId !== undefined && object.matchId !== null\n                ? Long.fromValue(object.matchId)\n                : Long.UZERO;\n        message.eventId = (_b = object.eventId) !== null && _b !== void 0 ? _b : 0;\n        message.eventType = (_c = object.eventType) !== null && _c !== void 0 ? _c : 0;\n        message.bPlayingCt = (_d = object.bPlayingCt) !== null && _d !== void 0 ? _d : false;\n        message.userPosX = (_e = object.userPosX) !== null && _e !== void 0 ? _e : 0;\n        message.userPosY = (_f = object.userPosY) !== null && _f !== void 0 ? _f : 0;\n        message.userPosZ = (_g = object.userPosZ) !== null && _g !== void 0 ? _g : 0;\n        message.userDefidx = (_h = object.userDefidx) !== null && _h !== void 0 ? _h : 0;\n        message.otherPosX = (_j = object.otherPosX) !== null && _j !== void 0 ? _j : 0;\n        message.otherPosY = (_k = object.otherPosY) !== null && _k !== void 0 ? _k : 0;\n        message.otherPosZ = (_l = object.otherPosZ) !== null && _l !== void 0 ? _l : 0;\n        message.otherDefidx = (_m = object.otherDefidx) !== null && _m !== void 0 ? _m : 0;\n        message.eventData = (_o = object.eventData) !== null && _o !== void 0 ? _o : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCServerQuestUpdateData() {\n    return {\n        playerQuestData: [],\n        binaryData: new Uint8Array(),\n        mmGameMode: 0,\n        missionlbsdata: undefined\n    };\n}\nexports.CMsgGCServerQuestUpdateData = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.playerQuestData) {\n            exports.PlayerQuestData.encode(v, writer.uint32(10).fork()).ldelim();\n        }\n        if (message.binaryData.length !== 0) {\n            writer.uint32(18).bytes(message.binaryData);\n        }\n        if (message.mmGameMode !== 0) {\n            writer.uint32(24).uint32(message.mmGameMode);\n        }\n        if (message.missionlbsdata !== undefined) {\n            exports.ScoreLeaderboardData.encode(message.missionlbsdata, writer.uint32(34).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCServerQuestUpdateData();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.playerQuestData.push(exports.PlayerQuestData.decode(reader, reader.uint32()));\n                    break;\n                case 2:\n                    message.binaryData = reader.bytes();\n                    break;\n                case 3:\n                    message.mmGameMode = reader.uint32();\n                    break;\n                case 4:\n                    message.missionlbsdata = exports.ScoreLeaderboardData.decode(reader, reader.uint32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCMsgGCServerQuestUpdateData();\n        message.playerQuestData =\n            ((_a = object.playerQuestData) === null || _a === void 0 ? void 0 : _a.map(e => exports.PlayerQuestData.fromPartial(e))) || [];\n        message.binaryData = (_b = object.binaryData) !== null && _b !== void 0 ? _b : new Uint8Array();\n        message.mmGameMode = (_c = object.mmGameMode) !== null && _c !== void 0 ? _c : 0;\n        message.missionlbsdata =\n            object.missionlbsdata !== undefined && object.missionlbsdata !== null\n                ? exports.ScoreLeaderboardData.fromPartial(object.missionlbsdata)\n                : undefined;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchmakingGCOperationalStats() {\n    return { packetid: 0, namekeys: [], packets: [] };\n}\nexports.CMsgGCCStrike15V2MatchmakingGCOperationalStats = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.packetid !== 0) {\n            writer.uint32(8).int32(message.packetid);\n        }\n        for (const v of message.namekeys) {\n            exports.OperationalStatisticDescription.encode(v, writer.uint32(18).fork()).ldelim();\n        }\n        for (const v of message.packets) {\n            exports.OperationalStatisticsPacket.encode(v, writer.uint32(26).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingGCOperationalStats();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.packetid = reader.int32();\n                    break;\n                case 2:\n                    message.namekeys.push(exports.OperationalStatisticDescription.decode(reader, reader.uint32()));\n                    break;\n                case 3:\n                    message.packets.push(exports.OperationalStatisticsPacket.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingGCOperationalStats();\n        message.packetid = (_a = object.packetid) !== null && _a !== void 0 ? _a : 0;\n        message.namekeys =\n            ((_b = object.namekeys) === null || _b === void 0 ? void 0 : _b.map(e => exports.OperationalStatisticDescription.fromPartial(e))) || [];\n        message.packets =\n            ((_c = object.packets) === null || _c === void 0 ? void 0 : _c.map(e => exports.OperationalStatisticsPacket.fromPartial(e))) ||\n                [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchmakingGC2ServerConfirm() {\n    return { token: 0, stamp: 0, exchange: Long.UZERO };\n}\nexports.CMsgGCCStrike15V2MatchmakingGC2ServerConfirm = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.token !== 0) {\n            writer.uint32(8).uint32(message.token);\n        }\n        if (message.stamp !== 0) {\n            writer.uint32(16).uint32(message.stamp);\n        }\n        if (!message.exchange.isZero()) {\n            writer.uint32(24).uint64(message.exchange);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ServerConfirm();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.token = reader.uint32();\n                    break;\n                case 2:\n                    message.stamp = reader.uint32();\n                    break;\n                case 3:\n                    message.exchange = reader.uint64();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ServerConfirm();\n        message.token = (_a = object.token) !== null && _a !== void 0 ? _a : 0;\n        message.stamp = (_b = object.stamp) !== null && _b !== void 0 ? _b : 0;\n        message.exchange =\n            object.exchange !== undefined && object.exchange !== null\n                ? Long.fromValue(object.exchange)\n                : Long.UZERO;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2GC2ServerReservationUpdate() {\n    return { viewersExternalTotal: 0, viewersExternalSteam: 0 };\n}\nexports.CMsgGCCStrike15V2GC2ServerReservationUpdate = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.viewersExternalTotal !== 0) {\n            writer.uint32(8).uint32(message.viewersExternalTotal);\n        }\n        if (message.viewersExternalSteam !== 0) {\n            writer.uint32(16).uint32(message.viewersExternalSteam);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2GC2ServerReservationUpdate();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.viewersExternalTotal = reader.uint32();\n                    break;\n                case 2:\n                    message.viewersExternalSteam = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2GC2ServerReservationUpdate();\n        message.viewersExternalTotal = (_a = object.viewersExternalTotal) !== null && _a !== void 0 ? _a : 0;\n        message.viewersExternalSteam = (_b = object.viewersExternalSteam) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchmakingStart() {\n    return {\n        accountIds: [],\n        gameType: 0,\n        ticketData: \"\",\n        clientVersion: 0,\n        tournamentMatch: undefined,\n        primeOnly: false,\n        tvControl: 0,\n        lobbyId: Long.UZERO\n    };\n}\nexports.CMsgGCCStrike15V2MatchmakingStart = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        writer.uint32(10).fork();\n        for (const v of message.accountIds) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        if (message.gameType !== 0) {\n            writer.uint32(16).uint32(message.gameType);\n        }\n        if (message.ticketData !== \"\") {\n            writer.uint32(26).string(message.ticketData);\n        }\n        if (message.clientVersion !== 0) {\n            writer.uint32(32).uint32(message.clientVersion);\n        }\n        if (message.tournamentMatch !== undefined) {\n            exports.TournamentMatchSetup.encode(message.tournamentMatch, writer.uint32(42).fork()).ldelim();\n        }\n        if (message.primeOnly === true) {\n            writer.uint32(48).bool(message.primeOnly);\n        }\n        if (message.tvControl !== 0) {\n            writer.uint32(56).uint32(message.tvControl);\n        }\n        if (!message.lobbyId.isZero()) {\n            writer.uint32(64).uint64(message.lobbyId);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingStart();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.accountIds.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.accountIds.push(reader.uint32());\n                    }\n                    break;\n                case 2:\n                    message.gameType = reader.uint32();\n                    break;\n                case 3:\n                    message.ticketData = reader.string();\n                    break;\n                case 4:\n                    message.clientVersion = reader.uint32();\n                    break;\n                case 5:\n                    message.tournamentMatch = exports.TournamentMatchSetup.decode(reader, reader.uint32());\n                    break;\n                case 6:\n                    message.primeOnly = reader.bool();\n                    break;\n                case 7:\n                    message.tvControl = reader.uint32();\n                    break;\n                case 8:\n                    message.lobbyId = reader.uint64();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingStart();\n        message.accountIds = ((_a = object.accountIds) === null || _a === void 0 ? void 0 : _a.map(e => e)) || [];\n        message.gameType = (_b = object.gameType) !== null && _b !== void 0 ? _b : 0;\n        message.ticketData = (_c = object.ticketData) !== null && _c !== void 0 ? _c : \"\";\n        message.clientVersion = (_d = object.clientVersion) !== null && _d !== void 0 ? _d : 0;\n        message.tournamentMatch =\n            object.tournamentMatch !== undefined && object.tournamentMatch !== null\n                ? exports.TournamentMatchSetup.fromPartial(object.tournamentMatch)\n                : undefined;\n        message.primeOnly = (_e = object.primeOnly) !== null && _e !== void 0 ? _e : false;\n        message.tvControl = (_f = object.tvControl) !== null && _f !== void 0 ? _f : 0;\n        message.lobbyId =\n            object.lobbyId !== undefined && object.lobbyId !== null\n                ? Long.fromValue(object.lobbyId)\n                : Long.UZERO;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchmakingStop() {\n    return { abandon: 0 };\n}\nexports.CMsgGCCStrike15V2MatchmakingStop = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.abandon !== 0) {\n            writer.uint32(8).int32(message.abandon);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingStop();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.abandon = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingStop();\n        message.abandon = (_a = object.abandon) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchmakingClient2ServerPing() {\n    return {\n        gameserverpings: [],\n        offsetIndex: 0,\n        finalBatch: 0,\n        dataCenterPings: [],\n        maxPing: 0,\n        testToken: 0\n    };\n}\nexports.CMsgGCCStrike15V2MatchmakingClient2ServerPing = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.gameserverpings) {\n            exports.GameServerPing.encode(v, writer.uint32(10).fork()).ldelim();\n        }\n        if (message.offsetIndex !== 0) {\n            writer.uint32(16).int32(message.offsetIndex);\n        }\n        if (message.finalBatch !== 0) {\n            writer.uint32(24).int32(message.finalBatch);\n        }\n        for (const v of message.dataCenterPings) {\n            exports.DataCenterPing.encode(v, writer.uint32(34).fork()).ldelim();\n        }\n        if (message.maxPing !== 0) {\n            writer.uint32(40).uint32(message.maxPing);\n        }\n        if (message.testToken !== 0) {\n            writer.uint32(53).fixed32(message.testToken);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingClient2ServerPing();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.gameserverpings.push(exports.GameServerPing.decode(reader, reader.uint32()));\n                    break;\n                case 2:\n                    message.offsetIndex = reader.int32();\n                    break;\n                case 3:\n                    message.finalBatch = reader.int32();\n                    break;\n                case 4:\n                    message.dataCenterPings.push(exports.DataCenterPing.decode(reader, reader.uint32()));\n                    break;\n                case 5:\n                    message.maxPing = reader.uint32();\n                    break;\n                case 6:\n                    message.testToken = reader.fixed32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingClient2ServerPing();\n        message.gameserverpings =\n            ((_a = object.gameserverpings) === null || _a === void 0 ? void 0 : _a.map(e => exports.GameServerPing.fromPartial(e))) || [];\n        message.offsetIndex = (_b = object.offsetIndex) !== null && _b !== void 0 ? _b : 0;\n        message.finalBatch = (_c = object.finalBatch) !== null && _c !== void 0 ? _c : 0;\n        message.dataCenterPings =\n            ((_d = object.dataCenterPings) === null || _d === void 0 ? void 0 : _d.map(e => exports.DataCenterPing.fromPartial(e))) || [];\n        message.maxPing = (_e = object.maxPing) !== null && _e !== void 0 ? _e : 0;\n        message.testToken = (_f = object.testToken) !== null && _f !== void 0 ? _f : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchmakingGC2ClientUpdate() {\n    return {\n        matchmaking: 0,\n        waitingAccountIdSessions: [],\n        error: \"\",\n        ongoingmatchAccountIdSessions: [],\n        globalStats: undefined,\n        failpingAccountIdSessions: [],\n        penaltyAccountIdSessions: [],\n        failreadyAccountIdSessions: [],\n        vacbannedAccountIdSessions: [],\n        serverIpaddressMask: undefined,\n        notes: [],\n        penaltyAccountIdSessionsGreen: [],\n        insufficientlevelSessions: [],\n        vsncheckAccountIdSessions: [],\n        launcherMismatchSessions: [],\n        insecureAccountIdSessions: []\n    };\n}\nexports.CMsgGCCStrike15V2MatchmakingGC2ClientUpdate = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.matchmaking !== 0) {\n            writer.uint32(8).int32(message.matchmaking);\n        }\n        writer.uint32(18).fork();\n        for (const v of message.waitingAccountIdSessions) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        if (message.error !== \"\") {\n            writer.uint32(26).string(message.error);\n        }\n        writer.uint32(50).fork();\n        for (const v of message.ongoingmatchAccountIdSessions) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        if (message.globalStats !== undefined) {\n            exports.GlobalStatistics.encode(message.globalStats, writer.uint32(58).fork()).ldelim();\n        }\n        writer.uint32(66).fork();\n        for (const v of message.failpingAccountIdSessions) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        writer.uint32(74).fork();\n        for (const v of message.penaltyAccountIdSessions) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        writer.uint32(82).fork();\n        for (const v of message.failreadyAccountIdSessions) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        writer.uint32(90).fork();\n        for (const v of message.vacbannedAccountIdSessions) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        if (message.serverIpaddressMask !== undefined) {\n            exports.IpAddressMask.encode(message.serverIpaddressMask, writer.uint32(98).fork()).ldelim();\n        }\n        for (const v of message.notes) {\n            exports.CMsgGCCStrike15V2MatchmakingGC2ClientUpdate_Note.encode(v, writer.uint32(106).fork()).ldelim();\n        }\n        writer.uint32(114).fork();\n        for (const v of message.penaltyAccountIdSessionsGreen) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        writer.uint32(122).fork();\n        for (const v of message.insufficientlevelSessions) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        writer.uint32(130).fork();\n        for (const v of message.vsncheckAccountIdSessions) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        writer.uint32(138).fork();\n        for (const v of message.launcherMismatchSessions) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        writer.uint32(146).fork();\n        for (const v of message.insecureAccountIdSessions) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientUpdate();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.matchmaking = reader.int32();\n                    break;\n                case 2:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.waitingAccountIdSessions.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.waitingAccountIdSessions.push(reader.uint32());\n                    }\n                    break;\n                case 3:\n                    message.error = reader.string();\n                    break;\n                case 6:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.ongoingmatchAccountIdSessions.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.ongoingmatchAccountIdSessions.push(reader.uint32());\n                    }\n                    break;\n                case 7:\n                    message.globalStats = exports.GlobalStatistics.decode(reader, reader.uint32());\n                    break;\n                case 8:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.failpingAccountIdSessions.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.failpingAccountIdSessions.push(reader.uint32());\n                    }\n                    break;\n                case 9:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.penaltyAccountIdSessions.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.penaltyAccountIdSessions.push(reader.uint32());\n                    }\n                    break;\n                case 10:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.failreadyAccountIdSessions.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.failreadyAccountIdSessions.push(reader.uint32());\n                    }\n                    break;\n                case 11:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.vacbannedAccountIdSessions.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.vacbannedAccountIdSessions.push(reader.uint32());\n                    }\n                    break;\n                case 12:\n                    message.serverIpaddressMask = exports.IpAddressMask.decode(reader, reader.uint32());\n                    break;\n                case 13:\n                    message.notes.push(exports.CMsgGCCStrike15V2MatchmakingGC2ClientUpdate_Note.decode(reader, reader.uint32()));\n                    break;\n                case 14:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.penaltyAccountIdSessionsGreen.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.penaltyAccountIdSessionsGreen.push(reader.uint32());\n                    }\n                    break;\n                case 15:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.insufficientlevelSessions.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.insufficientlevelSessions.push(reader.uint32());\n                    }\n                    break;\n                case 16:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.vsncheckAccountIdSessions.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.vsncheckAccountIdSessions.push(reader.uint32());\n                    }\n                    break;\n                case 17:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.launcherMismatchSessions.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.launcherMismatchSessions.push(reader.uint32());\n                    }\n                    break;\n                case 18:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.insecureAccountIdSessions.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.insecureAccountIdSessions.push(reader.uint32());\n                    }\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientUpdate();\n        message.matchmaking = (_a = object.matchmaking) !== null && _a !== void 0 ? _a : 0;\n        message.waitingAccountIdSessions =\n            ((_b = object.waitingAccountIdSessions) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];\n        message.error = (_c = object.error) !== null && _c !== void 0 ? _c : \"\";\n        message.ongoingmatchAccountIdSessions =\n            ((_d = object.ongoingmatchAccountIdSessions) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];\n        message.globalStats =\n            object.globalStats !== undefined && object.globalStats !== null\n                ? exports.GlobalStatistics.fromPartial(object.globalStats)\n                : undefined;\n        message.failpingAccountIdSessions =\n            ((_e = object.failpingAccountIdSessions) === null || _e === void 0 ? void 0 : _e.map(e => e)) || [];\n        message.penaltyAccountIdSessions =\n            ((_f = object.penaltyAccountIdSessions) === null || _f === void 0 ? void 0 : _f.map(e => e)) || [];\n        message.failreadyAccountIdSessions =\n            ((_g = object.failreadyAccountIdSessions) === null || _g === void 0 ? void 0 : _g.map(e => e)) || [];\n        message.vacbannedAccountIdSessions =\n            ((_h = object.vacbannedAccountIdSessions) === null || _h === void 0 ? void 0 : _h.map(e => e)) || [];\n        message.serverIpaddressMask =\n            object.serverIpaddressMask !== undefined &&\n                object.serverIpaddressMask !== null\n                ? exports.IpAddressMask.fromPartial(object.serverIpaddressMask)\n                : undefined;\n        message.notes =\n            ((_j = object.notes) === null || _j === void 0 ? void 0 : _j.map(e => exports.CMsgGCCStrike15V2MatchmakingGC2ClientUpdate_Note.fromPartial(e))) || [];\n        message.penaltyAccountIdSessionsGreen =\n            ((_k = object.penaltyAccountIdSessionsGreen) === null || _k === void 0 ? void 0 : _k.map(e => e)) || [];\n        message.insufficientlevelSessions =\n            ((_l = object.insufficientlevelSessions) === null || _l === void 0 ? void 0 : _l.map(e => e)) || [];\n        message.vsncheckAccountIdSessions =\n            ((_m = object.vsncheckAccountIdSessions) === null || _m === void 0 ? void 0 : _m.map(e => e)) || [];\n        message.launcherMismatchSessions =\n            ((_o = object.launcherMismatchSessions) === null || _o === void 0 ? void 0 : _o.map(e => e)) || [];\n        message.insecureAccountIdSessions =\n            ((_p = object.insecureAccountIdSessions) === null || _p === void 0 ? void 0 : _p.map(e => e)) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchmakingGC2ClientUpdate_Note() {\n    return { type: 0, regionId: 0, regionR: 0, distance: 0 };\n}\nexports.CMsgGCCStrike15V2MatchmakingGC2ClientUpdate_Note = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.type !== 0) {\n            writer.uint32(8).int32(message.type);\n        }\n        if (message.regionId !== 0) {\n            writer.uint32(16).int32(message.regionId);\n        }\n        if (message.regionR !== 0) {\n            writer.uint32(29).float(message.regionR);\n        }\n        if (message.distance !== 0) {\n            writer.uint32(37).float(message.distance);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientUpdate_Note();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.type = reader.int32();\n                    break;\n                case 2:\n                    message.regionId = reader.int32();\n                    break;\n                case 3:\n                    message.regionR = reader.float();\n                    break;\n                case 4:\n                    message.distance = reader.float();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientUpdate_Note();\n        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;\n        message.regionId = (_b = object.regionId) !== null && _b !== void 0 ? _b : 0;\n        message.regionR = (_c = object.regionR) !== null && _c !== void 0 ? _c : 0;\n        message.distance = (_d = object.distance) !== null && _d !== void 0 ? _d : 0;\n        return message;\n    }\n};\nfunction createBaseCDataGCCStrike15V2TournamentMatchDraft() {\n    return {\n        eventId: 0,\n        eventStageId: 0,\n        teamId0: 0,\n        teamId1: 0,\n        mapsCount: 0,\n        mapsCurrent: 0,\n        teamIdStart: 0,\n        teamIdVeto1: 0,\n        teamIdPickn: 0,\n        drafts: []\n    };\n}\nexports.CDataGCCStrike15V2TournamentMatchDraft = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.eventId !== 0) {\n            writer.uint32(8).int32(message.eventId);\n        }\n        if (message.eventStageId !== 0) {\n            writer.uint32(16).int32(message.eventStageId);\n        }\n        if (message.teamId0 !== 0) {\n            writer.uint32(24).int32(message.teamId0);\n        }\n        if (message.teamId1 !== 0) {\n            writer.uint32(32).int32(message.teamId1);\n        }\n        if (message.mapsCount !== 0) {\n            writer.uint32(40).int32(message.mapsCount);\n        }\n        if (message.mapsCurrent !== 0) {\n            writer.uint32(48).int32(message.mapsCurrent);\n        }\n        if (message.teamIdStart !== 0) {\n            writer.uint32(56).int32(message.teamIdStart);\n        }\n        if (message.teamIdVeto1 !== 0) {\n            writer.uint32(64).int32(message.teamIdVeto1);\n        }\n        if (message.teamIdPickn !== 0) {\n            writer.uint32(72).int32(message.teamIdPickn);\n        }\n        for (const v of message.drafts) {\n            exports.CDataGCCStrike15V2TournamentMatchDraft_Entry.encode(v, writer.uint32(82).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCDataGCCStrike15V2TournamentMatchDraft();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.eventId = reader.int32();\n                    break;\n                case 2:\n                    message.eventStageId = reader.int32();\n                    break;\n                case 3:\n                    message.teamId0 = reader.int32();\n                    break;\n                case 4:\n                    message.teamId1 = reader.int32();\n                    break;\n                case 5:\n                    message.mapsCount = reader.int32();\n                    break;\n                case 6:\n                    message.mapsCurrent = reader.int32();\n                    break;\n                case 7:\n                    message.teamIdStart = reader.int32();\n                    break;\n                case 8:\n                    message.teamIdVeto1 = reader.int32();\n                    break;\n                case 9:\n                    message.teamIdPickn = reader.int32();\n                    break;\n                case 10:\n                    message.drafts.push(exports.CDataGCCStrike15V2TournamentMatchDraft_Entry.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;\n        const message = createBaseCDataGCCStrike15V2TournamentMatchDraft();\n        message.eventId = (_a = object.eventId) !== null && _a !== void 0 ? _a : 0;\n        message.eventStageId = (_b = object.eventStageId) !== null && _b !== void 0 ? _b : 0;\n        message.teamId0 = (_c = object.teamId0) !== null && _c !== void 0 ? _c : 0;\n        message.teamId1 = (_d = object.teamId1) !== null && _d !== void 0 ? _d : 0;\n        message.mapsCount = (_e = object.mapsCount) !== null && _e !== void 0 ? _e : 0;\n        message.mapsCurrent = (_f = object.mapsCurrent) !== null && _f !== void 0 ? _f : 0;\n        message.teamIdStart = (_g = object.teamIdStart) !== null && _g !== void 0 ? _g : 0;\n        message.teamIdVeto1 = (_h = object.teamIdVeto1) !== null && _h !== void 0 ? _h : 0;\n        message.teamIdPickn = (_j = object.teamIdPickn) !== null && _j !== void 0 ? _j : 0;\n        message.drafts =\n            ((_k = object.drafts) === null || _k === void 0 ? void 0 : _k.map(e => exports.CDataGCCStrike15V2TournamentMatchDraft_Entry.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCDataGCCStrike15V2TournamentMatchDraft_Entry() {\n    return { mapid: 0, teamIdCt: 0 };\n}\nexports.CDataGCCStrike15V2TournamentMatchDraft_Entry = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.mapid !== 0) {\n            writer.uint32(8).int32(message.mapid);\n        }\n        if (message.teamIdCt !== 0) {\n            writer.uint32(16).int32(message.teamIdCt);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCDataGCCStrike15V2TournamentMatchDraft_Entry();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.mapid = reader.int32();\n                    break;\n                case 2:\n                    message.teamIdCt = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCDataGCCStrike15V2TournamentMatchDraft_Entry();\n        message.mapid = (_a = object.mapid) !== null && _a !== void 0 ? _a : 0;\n        message.teamIdCt = (_b = object.teamIdCt) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCPreMatchInfoData() {\n    return { predictionsPct: 0, draft: undefined, stats: [], wins: [] };\n}\nexports.CPreMatchInfoData = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.predictionsPct !== 0) {\n            writer.uint32(8).int32(message.predictionsPct);\n        }\n        if (message.draft !== undefined) {\n            exports.CDataGCCStrike15V2TournamentMatchDraft.encode(message.draft, writer.uint32(34).fork()).ldelim();\n        }\n        for (const v of message.stats) {\n            exports.CPreMatchInfoData_TeamStats.encode(v, writer.uint32(42).fork()).ldelim();\n        }\n        writer.uint32(50).fork();\n        for (const v of message.wins) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCPreMatchInfoData();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.predictionsPct = reader.int32();\n                    break;\n                case 4:\n                    message.draft = exports.CDataGCCStrike15V2TournamentMatchDraft.decode(reader, reader.uint32());\n                    break;\n                case 5:\n                    message.stats.push(exports.CPreMatchInfoData_TeamStats.decode(reader, reader.uint32()));\n                    break;\n                case 6:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.wins.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.wins.push(reader.int32());\n                    }\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCPreMatchInfoData();\n        message.predictionsPct = (_a = object.predictionsPct) !== null && _a !== void 0 ? _a : 0;\n        message.draft =\n            object.draft !== undefined && object.draft !== null\n                ? exports.CDataGCCStrike15V2TournamentMatchDraft.fromPartial(object.draft)\n                : undefined;\n        message.stats =\n            ((_b = object.stats) === null || _b === void 0 ? void 0 : _b.map(e => exports.CPreMatchInfoData_TeamStats.fromPartial(e))) || [];\n        message.wins = ((_c = object.wins) === null || _c === void 0 ? void 0 : _c.map(e => e)) || [];\n        return message;\n    }\n};\nfunction createBaseCPreMatchInfoData_TeamStats() {\n    return { matchInfoIdxtxt: 0, matchInfoTxt: \"\", matchInfoTeams: [] };\n}\nexports.CPreMatchInfoData_TeamStats = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.matchInfoIdxtxt !== 0) {\n            writer.uint32(8).int32(message.matchInfoIdxtxt);\n        }\n        if (message.matchInfoTxt !== \"\") {\n            writer.uint32(18).string(message.matchInfoTxt);\n        }\n        for (const v of message.matchInfoTeams) {\n            writer.uint32(26).string(v);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCPreMatchInfoData_TeamStats();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.matchInfoIdxtxt = reader.int32();\n                    break;\n                case 2:\n                    message.matchInfoTxt = reader.string();\n                    break;\n                case 3:\n                    message.matchInfoTeams.push(reader.string());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCPreMatchInfoData_TeamStats();\n        message.matchInfoIdxtxt = (_a = object.matchInfoIdxtxt) !== null && _a !== void 0 ? _a : 0;\n        message.matchInfoTxt = (_b = object.matchInfoTxt) !== null && _b !== void 0 ? _b : \"\";\n        message.matchInfoTeams = ((_c = object.matchInfoTeams) === null || _c === void 0 ? void 0 : _c.map(e => e)) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchmakingGC2ServerReserve() {\n    return {\n        accountIds: [],\n        gameType: 0,\n        matchId: Long.UZERO,\n        serverVersion: 0,\n        flags: 0,\n        rankings: [],\n        encryptionKey: Long.UZERO,\n        encryptionKeyPub: Long.UZERO,\n        partyIds: [],\n        whitelist: [],\n        tvMasterSteamid: Long.UZERO,\n        tournamentEvent: undefined,\n        tournamentTeams: [],\n        tournamentCastersAccountIds: [],\n        tvRelaySteamid: Long.UZERO,\n        preMatchData: undefined,\n        rtime32EventStart: 0,\n        tvControl: 0\n    };\n}\nexports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        writer.uint32(10).fork();\n        for (const v of message.accountIds) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        if (message.gameType !== 0) {\n            writer.uint32(16).uint32(message.gameType);\n        }\n        if (!message.matchId.isZero()) {\n            writer.uint32(24).uint64(message.matchId);\n        }\n        if (message.serverVersion !== 0) {\n            writer.uint32(32).uint32(message.serverVersion);\n        }\n        if (message.flags !== 0) {\n            writer.uint32(144).uint32(message.flags);\n        }\n        for (const v of message.rankings) {\n            exports.PlayerRankingInfo.encode(v, writer.uint32(42).fork()).ldelim();\n        }\n        if (!message.encryptionKey.isZero()) {\n            writer.uint32(48).uint64(message.encryptionKey);\n        }\n        if (!message.encryptionKeyPub.isZero()) {\n            writer.uint32(56).uint64(message.encryptionKeyPub);\n        }\n        writer.uint32(66).fork();\n        for (const v of message.partyIds) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        for (const v of message.whitelist) {\n            exports.IpAddressMask.encode(v, writer.uint32(74).fork()).ldelim();\n        }\n        if (!message.tvMasterSteamid.isZero()) {\n            writer.uint32(80).uint64(message.tvMasterSteamid);\n        }\n        if (message.tournamentEvent !== undefined) {\n            exports.TournamentEvent.encode(message.tournamentEvent, writer.uint32(90).fork()).ldelim();\n        }\n        for (const v of message.tournamentTeams) {\n            exports.TournamentTeam.encode(v, writer.uint32(98).fork()).ldelim();\n        }\n        writer.uint32(106).fork();\n        for (const v of message.tournamentCastersAccountIds) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        if (!message.tvRelaySteamid.isZero()) {\n            writer.uint32(112).uint64(message.tvRelaySteamid);\n        }\n        if (message.preMatchData !== undefined) {\n            exports.CPreMatchInfoData.encode(message.preMatchData, writer.uint32(122).fork()).ldelim();\n        }\n        if (message.rtime32EventStart !== 0) {\n            writer.uint32(128).uint32(message.rtime32EventStart);\n        }\n        if (message.tvControl !== 0) {\n            writer.uint32(136).uint32(message.tvControl);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ServerReserve();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.accountIds.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.accountIds.push(reader.uint32());\n                    }\n                    break;\n                case 2:\n                    message.gameType = reader.uint32();\n                    break;\n                case 3:\n                    message.matchId = reader.uint64();\n                    break;\n                case 4:\n                    message.serverVersion = reader.uint32();\n                    break;\n                case 18:\n                    message.flags = reader.uint32();\n                    break;\n                case 5:\n                    message.rankings.push(exports.PlayerRankingInfo.decode(reader, reader.uint32()));\n                    break;\n                case 6:\n                    message.encryptionKey = reader.uint64();\n                    break;\n                case 7:\n                    message.encryptionKeyPub = reader.uint64();\n                    break;\n                case 8:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.partyIds.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.partyIds.push(reader.uint32());\n                    }\n                    break;\n                case 9:\n                    message.whitelist.push(exports.IpAddressMask.decode(reader, reader.uint32()));\n                    break;\n                case 10:\n                    message.tvMasterSteamid = reader.uint64();\n                    break;\n                case 11:\n                    message.tournamentEvent = exports.TournamentEvent.decode(reader, reader.uint32());\n                    break;\n                case 12:\n                    message.tournamentTeams.push(exports.TournamentTeam.decode(reader, reader.uint32()));\n                    break;\n                case 13:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.tournamentCastersAccountIds.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.tournamentCastersAccountIds.push(reader.uint32());\n                    }\n                    break;\n                case 14:\n                    message.tvRelaySteamid = reader.uint64();\n                    break;\n                case 15:\n                    message.preMatchData = exports.CPreMatchInfoData.decode(reader, reader.uint32());\n                    break;\n                case 16:\n                    message.rtime32EventStart = reader.uint32();\n                    break;\n                case 17:\n                    message.tvControl = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ServerReserve();\n        message.accountIds = ((_a = object.accountIds) === null || _a === void 0 ? void 0 : _a.map(e => e)) || [];\n        message.gameType = (_b = object.gameType) !== null && _b !== void 0 ? _b : 0;\n        message.matchId =\n            object.matchId !== undefined && object.matchId !== null\n                ? Long.fromValue(object.matchId)\n                : Long.UZERO;\n        message.serverVersion = (_c = object.serverVersion) !== null && _c !== void 0 ? _c : 0;\n        message.flags = (_d = object.flags) !== null && _d !== void 0 ? _d : 0;\n        message.rankings =\n            ((_e = object.rankings) === null || _e === void 0 ? void 0 : _e.map(e => exports.PlayerRankingInfo.fromPartial(e))) || [];\n        message.encryptionKey =\n            object.encryptionKey !== undefined && object.encryptionKey !== null\n                ? Long.fromValue(object.encryptionKey)\n                : Long.UZERO;\n        message.encryptionKeyPub =\n            object.encryptionKeyPub !== undefined && object.encryptionKeyPub !== null\n                ? Long.fromValue(object.encryptionKeyPub)\n                : Long.UZERO;\n        message.partyIds = ((_f = object.partyIds) === null || _f === void 0 ? void 0 : _f.map(e => e)) || [];\n        message.whitelist =\n            ((_g = object.whitelist) === null || _g === void 0 ? void 0 : _g.map(e => exports.IpAddressMask.fromPartial(e))) || [];\n        message.tvMasterSteamid =\n            object.tvMasterSteamid !== undefined && object.tvMasterSteamid !== null\n                ? Long.fromValue(object.tvMasterSteamid)\n                : Long.UZERO;\n        message.tournamentEvent =\n            object.tournamentEvent !== undefined && object.tournamentEvent !== null\n                ? exports.TournamentEvent.fromPartial(object.tournamentEvent)\n                : undefined;\n        message.tournamentTeams =\n            ((_h = object.tournamentTeams) === null || _h === void 0 ? void 0 : _h.map(e => exports.TournamentTeam.fromPartial(e))) || [];\n        message.tournamentCastersAccountIds =\n            ((_j = object.tournamentCastersAccountIds) === null || _j === void 0 ? void 0 : _j.map(e => e)) || [];\n        message.tvRelaySteamid =\n            object.tvRelaySteamid !== undefined && object.tvRelaySteamid !== null\n                ? Long.fromValue(object.tvRelaySteamid)\n                : Long.UZERO;\n        message.preMatchData =\n            object.preMatchData !== undefined && object.preMatchData !== null\n                ? exports.CPreMatchInfoData.fromPartial(object.preMatchData)\n                : undefined;\n        message.rtime32EventStart = (_k = object.rtime32EventStart) !== null && _k !== void 0 ? _k : 0;\n        message.tvControl = (_l = object.tvControl) !== null && _l !== void 0 ? _l : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchmakingServerReservationResponse() {\n    return {\n        reservationid: Long.UZERO,\n        reservation: undefined,\n        map: \"\",\n        gcReservationSent: Long.UZERO,\n        serverVersion: 0,\n        tvInfo: undefined,\n        rewardPlayerAccounts: [],\n        idlePlayerAccounts: [],\n        rewardItemAttrDefIdx: 0,\n        rewardItemAttrValue: 0,\n        rewardItemAttrRewardIdx: 0,\n        rewardDropList: 0,\n        tournamentTag: \"\",\n        legacySteamdatagramPort: 0,\n        steamdatagramRouting: 0,\n        testToken: 0,\n        flags: 0\n    };\n}\nexports.CMsgGCCStrike15V2MatchmakingServerReservationResponse = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.reservationid.isZero()) {\n            writer.uint32(8).uint64(message.reservationid);\n        }\n        if (message.reservation !== undefined) {\n            exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.encode(message.reservation, writer.uint32(18).fork()).ldelim();\n        }\n        if (message.map !== \"\") {\n            writer.uint32(26).string(message.map);\n        }\n        if (!message.gcReservationSent.isZero()) {\n            writer.uint32(32).uint64(message.gcReservationSent);\n        }\n        if (message.serverVersion !== 0) {\n            writer.uint32(40).uint32(message.serverVersion);\n        }\n        if (message.tvInfo !== undefined) {\n            exports.ServerHltvInfo.encode(message.tvInfo, writer.uint32(50).fork()).ldelim();\n        }\n        writer.uint32(58).fork();\n        for (const v of message.rewardPlayerAccounts) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        writer.uint32(66).fork();\n        for (const v of message.idlePlayerAccounts) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        if (message.rewardItemAttrDefIdx !== 0) {\n            writer.uint32(72).uint32(message.rewardItemAttrDefIdx);\n        }\n        if (message.rewardItemAttrValue !== 0) {\n            writer.uint32(80).uint32(message.rewardItemAttrValue);\n        }\n        if (message.rewardItemAttrRewardIdx !== 0) {\n            writer.uint32(88).uint32(message.rewardItemAttrRewardIdx);\n        }\n        if (message.rewardDropList !== 0) {\n            writer.uint32(96).uint32(message.rewardDropList);\n        }\n        if (message.tournamentTag !== \"\") {\n            writer.uint32(106).string(message.tournamentTag);\n        }\n        if (message.legacySteamdatagramPort !== 0) {\n            writer.uint32(112).uint32(message.legacySteamdatagramPort);\n        }\n        if (message.steamdatagramRouting !== 0) {\n            writer.uint32(136).uint32(message.steamdatagramRouting);\n        }\n        if (message.testToken !== 0) {\n            writer.uint32(125).fixed32(message.testToken);\n        }\n        if (message.flags !== 0) {\n            writer.uint32(128).uint32(message.flags);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingServerReservationResponse();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.reservationid = reader.uint64();\n                    break;\n                case 2:\n                    message.reservation =\n                        exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.decode(reader, reader.uint32());\n                    break;\n                case 3:\n                    message.map = reader.string();\n                    break;\n                case 4:\n                    message.gcReservationSent = reader.uint64();\n                    break;\n                case 5:\n                    message.serverVersion = reader.uint32();\n                    break;\n                case 6:\n                    message.tvInfo = exports.ServerHltvInfo.decode(reader, reader.uint32());\n                    break;\n                case 7:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.rewardPlayerAccounts.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.rewardPlayerAccounts.push(reader.uint32());\n                    }\n                    break;\n                case 8:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.idlePlayerAccounts.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.idlePlayerAccounts.push(reader.uint32());\n                    }\n                    break;\n                case 9:\n                    message.rewardItemAttrDefIdx = reader.uint32();\n                    break;\n                case 10:\n                    message.rewardItemAttrValue = reader.uint32();\n                    break;\n                case 11:\n                    message.rewardItemAttrRewardIdx = reader.uint32();\n                    break;\n                case 12:\n                    message.rewardDropList = reader.uint32();\n                    break;\n                case 13:\n                    message.tournamentTag = reader.string();\n                    break;\n                case 14:\n                    message.legacySteamdatagramPort = reader.uint32();\n                    break;\n                case 17:\n                    message.steamdatagramRouting = reader.uint32();\n                    break;\n                case 15:\n                    message.testToken = reader.fixed32();\n                    break;\n                case 16:\n                    message.flags = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingServerReservationResponse();\n        message.reservationid =\n            object.reservationid !== undefined && object.reservationid !== null\n                ? Long.fromValue(object.reservationid)\n                : Long.UZERO;\n        message.reservation =\n            object.reservation !== undefined && object.reservation !== null\n                ? exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.fromPartial(object.reservation)\n                : undefined;\n        message.map = (_a = object.map) !== null && _a !== void 0 ? _a : \"\";\n        message.gcReservationSent =\n            object.gcReservationSent !== undefined &&\n                object.gcReservationSent !== null\n                ? Long.fromValue(object.gcReservationSent)\n                : Long.UZERO;\n        message.serverVersion = (_b = object.serverVersion) !== null && _b !== void 0 ? _b : 0;\n        message.tvInfo =\n            object.tvInfo !== undefined && object.tvInfo !== null\n                ? exports.ServerHltvInfo.fromPartial(object.tvInfo)\n                : undefined;\n        message.rewardPlayerAccounts =\n            ((_c = object.rewardPlayerAccounts) === null || _c === void 0 ? void 0 : _c.map(e => e)) || [];\n        message.idlePlayerAccounts = ((_d = object.idlePlayerAccounts) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];\n        message.rewardItemAttrDefIdx = (_e = object.rewardItemAttrDefIdx) !== null && _e !== void 0 ? _e : 0;\n        message.rewardItemAttrValue = (_f = object.rewardItemAttrValue) !== null && _f !== void 0 ? _f : 0;\n        message.rewardItemAttrRewardIdx = (_g = object.rewardItemAttrRewardIdx) !== null && _g !== void 0 ? _g : 0;\n        message.rewardDropList = (_h = object.rewardDropList) !== null && _h !== void 0 ? _h : 0;\n        message.tournamentTag = (_j = object.tournamentTag) !== null && _j !== void 0 ? _j : \"\";\n        message.legacySteamdatagramPort = (_k = object.legacySteamdatagramPort) !== null && _k !== void 0 ? _k : 0;\n        message.steamdatagramRouting = (_l = object.steamdatagramRouting) !== null && _l !== void 0 ? _l : 0;\n        message.testToken = (_m = object.testToken) !== null && _m !== void 0 ? _m : 0;\n        message.flags = (_o = object.flags) !== null && _o !== void 0 ? _o : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchmakingGC2ClientReserve() {\n    return {\n        serverid: Long.UZERO,\n        directUdpIp: 0,\n        directUdpPort: 0,\n        reservationid: Long.UZERO,\n        reservation: undefined,\n        map: \"\",\n        serverAddress: \"\"\n    };\n}\nexports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.serverid.isZero()) {\n            writer.uint32(8).uint64(message.serverid);\n        }\n        if (message.directUdpIp !== 0) {\n            writer.uint32(16).uint32(message.directUdpIp);\n        }\n        if (message.directUdpPort !== 0) {\n            writer.uint32(24).uint32(message.directUdpPort);\n        }\n        if (!message.reservationid.isZero()) {\n            writer.uint32(32).uint64(message.reservationid);\n        }\n        if (message.reservation !== undefined) {\n            exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.encode(message.reservation, writer.uint32(42).fork()).ldelim();\n        }\n        if (message.map !== \"\") {\n            writer.uint32(50).string(message.map);\n        }\n        if (message.serverAddress !== \"\") {\n            writer.uint32(58).string(message.serverAddress);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientReserve();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.serverid = reader.uint64();\n                    break;\n                case 2:\n                    message.directUdpIp = reader.uint32();\n                    break;\n                case 3:\n                    message.directUdpPort = reader.uint32();\n                    break;\n                case 4:\n                    message.reservationid = reader.uint64();\n                    break;\n                case 5:\n                    message.reservation =\n                        exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.decode(reader, reader.uint32());\n                    break;\n                case 6:\n                    message.map = reader.string();\n                    break;\n                case 7:\n                    message.serverAddress = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientReserve();\n        message.serverid =\n            object.serverid !== undefined && object.serverid !== null\n                ? Long.fromValue(object.serverid)\n                : Long.UZERO;\n        message.directUdpIp = (_a = object.directUdpIp) !== null && _a !== void 0 ? _a : 0;\n        message.directUdpPort = (_b = object.directUdpPort) !== null && _b !== void 0 ? _b : 0;\n        message.reservationid =\n            object.reservationid !== undefined && object.reservationid !== null\n                ? Long.fromValue(object.reservationid)\n                : Long.UZERO;\n        message.reservation =\n            object.reservation !== undefined && object.reservation !== null\n                ? exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.fromPartial(object.reservation)\n                : undefined;\n        message.map = (_c = object.map) !== null && _c !== void 0 ? _c : \"\";\n        message.serverAddress = (_d = object.serverAddress) !== null && _d !== void 0 ? _d : \"\";\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchmakingServerRoundStats() {\n    return {\n        reservationid: Long.UZERO,\n        reservation: undefined,\n        map: \"\",\n        round: 0,\n        kills: [],\n        assists: [],\n        deaths: [],\n        scores: [],\n        pings: [],\n        roundResult: 0,\n        matchResult: 0,\n        teamScores: [],\n        confirm: undefined,\n        reservationStage: 0,\n        matchDuration: 0,\n        enemyKills: [],\n        enemyHeadshots: [],\n        enemy3ks: [],\n        enemy4ks: [],\n        enemy5ks: [],\n        mvps: [],\n        spectatorsCount: 0,\n        spectatorsCountTv: 0,\n        spectatorsCountLnk: 0,\n        enemyKillsAgg: [],\n        dropInfo: undefined,\n        bSwitchedTeams: false,\n        enemy2ks: [],\n        playerSpawned: [],\n        teamSpawnCount: [],\n        maxRounds: 0\n    };\n}\nexports.CMsgGCCStrike15V2MatchmakingServerRoundStats = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.reservationid.isZero()) {\n            writer.uint32(8).uint64(message.reservationid);\n        }\n        if (message.reservation !== undefined) {\n            exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.encode(message.reservation, writer.uint32(18).fork()).ldelim();\n        }\n        if (message.map !== \"\") {\n            writer.uint32(26).string(message.map);\n        }\n        if (message.round !== 0) {\n            writer.uint32(32).int32(message.round);\n        }\n        writer.uint32(42).fork();\n        for (const v of message.kills) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        writer.uint32(50).fork();\n        for (const v of message.assists) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        writer.uint32(58).fork();\n        for (const v of message.deaths) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        writer.uint32(66).fork();\n        for (const v of message.scores) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        writer.uint32(74).fork();\n        for (const v of message.pings) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        if (message.roundResult !== 0) {\n            writer.uint32(80).int32(message.roundResult);\n        }\n        if (message.matchResult !== 0) {\n            writer.uint32(88).int32(message.matchResult);\n        }\n        writer.uint32(98).fork();\n        for (const v of message.teamScores) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        if (message.confirm !== undefined) {\n            exports.CMsgGCCStrike15V2MatchmakingGC2ServerConfirm.encode(message.confirm, writer.uint32(106).fork()).ldelim();\n        }\n        if (message.reservationStage !== 0) {\n            writer.uint32(112).int32(message.reservationStage);\n        }\n        if (message.matchDuration !== 0) {\n            writer.uint32(120).int32(message.matchDuration);\n        }\n        writer.uint32(130).fork();\n        for (const v of message.enemyKills) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        writer.uint32(138).fork();\n        for (const v of message.enemyHeadshots) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        writer.uint32(146).fork();\n        for (const v of message.enemy3ks) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        writer.uint32(154).fork();\n        for (const v of message.enemy4ks) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        writer.uint32(162).fork();\n        for (const v of message.enemy5ks) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        writer.uint32(170).fork();\n        for (const v of message.mvps) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        if (message.spectatorsCount !== 0) {\n            writer.uint32(176).uint32(message.spectatorsCount);\n        }\n        if (message.spectatorsCountTv !== 0) {\n            writer.uint32(184).uint32(message.spectatorsCountTv);\n        }\n        if (message.spectatorsCountLnk !== 0) {\n            writer.uint32(192).uint32(message.spectatorsCountLnk);\n        }\n        writer.uint32(202).fork();\n        for (const v of message.enemyKillsAgg) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        if (message.dropInfo !== undefined) {\n            exports.CMsgGCCStrike15V2MatchmakingServerRoundStats_DropInfo.encode(message.dropInfo, writer.uint32(210).fork()).ldelim();\n        }\n        if (message.bSwitchedTeams === true) {\n            writer.uint32(216).bool(message.bSwitchedTeams);\n        }\n        writer.uint32(226).fork();\n        for (const v of message.enemy2ks) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        writer.uint32(234).fork();\n        for (const v of message.playerSpawned) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        writer.uint32(242).fork();\n        for (const v of message.teamSpawnCount) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        if (message.maxRounds !== 0) {\n            writer.uint32(248).uint32(message.maxRounds);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingServerRoundStats();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.reservationid = reader.uint64();\n                    break;\n                case 2:\n                    message.reservation =\n                        exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.decode(reader, reader.uint32());\n                    break;\n                case 3:\n                    message.map = reader.string();\n                    break;\n                case 4:\n                    message.round = reader.int32();\n                    break;\n                case 5:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.kills.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.kills.push(reader.int32());\n                    }\n                    break;\n                case 6:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.assists.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.assists.push(reader.int32());\n                    }\n                    break;\n                case 7:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.deaths.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.deaths.push(reader.int32());\n                    }\n                    break;\n                case 8:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.scores.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.scores.push(reader.int32());\n                    }\n                    break;\n                case 9:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.pings.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.pings.push(reader.int32());\n                    }\n                    break;\n                case 10:\n                    message.roundResult = reader.int32();\n                    break;\n                case 11:\n                    message.matchResult = reader.int32();\n                    break;\n                case 12:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.teamScores.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.teamScores.push(reader.int32());\n                    }\n                    break;\n                case 13:\n                    message.confirm = exports.CMsgGCCStrike15V2MatchmakingGC2ServerConfirm.decode(reader, reader.uint32());\n                    break;\n                case 14:\n                    message.reservationStage = reader.int32();\n                    break;\n                case 15:\n                    message.matchDuration = reader.int32();\n                    break;\n                case 16:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.enemyKills.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.enemyKills.push(reader.int32());\n                    }\n                    break;\n                case 17:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.enemyHeadshots.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.enemyHeadshots.push(reader.int32());\n                    }\n                    break;\n                case 18:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.enemy3ks.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.enemy3ks.push(reader.int32());\n                    }\n                    break;\n                case 19:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.enemy4ks.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.enemy4ks.push(reader.int32());\n                    }\n                    break;\n                case 20:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.enemy5ks.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.enemy5ks.push(reader.int32());\n                    }\n                    break;\n                case 21:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.mvps.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.mvps.push(reader.int32());\n                    }\n                    break;\n                case 22:\n                    message.spectatorsCount = reader.uint32();\n                    break;\n                case 23:\n                    message.spectatorsCountTv = reader.uint32();\n                    break;\n                case 24:\n                    message.spectatorsCountLnk = reader.uint32();\n                    break;\n                case 25:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.enemyKillsAgg.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.enemyKillsAgg.push(reader.int32());\n                    }\n                    break;\n                case 26:\n                    message.dropInfo =\n                        exports.CMsgGCCStrike15V2MatchmakingServerRoundStats_DropInfo.decode(reader, reader.uint32());\n                    break;\n                case 27:\n                    message.bSwitchedTeams = reader.bool();\n                    break;\n                case 28:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.enemy2ks.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.enemy2ks.push(reader.int32());\n                    }\n                    break;\n                case 29:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.playerSpawned.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.playerSpawned.push(reader.int32());\n                    }\n                    break;\n                case 30:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.teamSpawnCount.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.teamSpawnCount.push(reader.int32());\n                    }\n                    break;\n                case 31:\n                    message.maxRounds = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingServerRoundStats();\n        message.reservationid =\n            object.reservationid !== undefined && object.reservationid !== null\n                ? Long.fromValue(object.reservationid)\n                : Long.UZERO;\n        message.reservation =\n            object.reservation !== undefined && object.reservation !== null\n                ? exports.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.fromPartial(object.reservation)\n                : undefined;\n        message.map = (_a = object.map) !== null && _a !== void 0 ? _a : \"\";\n        message.round = (_b = object.round) !== null && _b !== void 0 ? _b : 0;\n        message.kills = ((_c = object.kills) === null || _c === void 0 ? void 0 : _c.map(e => e)) || [];\n        message.assists = ((_d = object.assists) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];\n        message.deaths = ((_e = object.deaths) === null || _e === void 0 ? void 0 : _e.map(e => e)) || [];\n        message.scores = ((_f = object.scores) === null || _f === void 0 ? void 0 : _f.map(e => e)) || [];\n        message.pings = ((_g = object.pings) === null || _g === void 0 ? void 0 : _g.map(e => e)) || [];\n        message.roundResult = (_h = object.roundResult) !== null && _h !== void 0 ? _h : 0;\n        message.matchResult = (_j = object.matchResult) !== null && _j !== void 0 ? _j : 0;\n        message.teamScores = ((_k = object.teamScores) === null || _k === void 0 ? void 0 : _k.map(e => e)) || [];\n        message.confirm =\n            object.confirm !== undefined && object.confirm !== null\n                ? exports.CMsgGCCStrike15V2MatchmakingGC2ServerConfirm.fromPartial(object.confirm)\n                : undefined;\n        message.reservationStage = (_l = object.reservationStage) !== null && _l !== void 0 ? _l : 0;\n        message.matchDuration = (_m = object.matchDuration) !== null && _m !== void 0 ? _m : 0;\n        message.enemyKills = ((_o = object.enemyKills) === null || _o === void 0 ? void 0 : _o.map(e => e)) || [];\n        message.enemyHeadshots = ((_p = object.enemyHeadshots) === null || _p === void 0 ? void 0 : _p.map(e => e)) || [];\n        message.enemy3ks = ((_q = object.enemy3ks) === null || _q === void 0 ? void 0 : _q.map(e => e)) || [];\n        message.enemy4ks = ((_r = object.enemy4ks) === null || _r === void 0 ? void 0 : _r.map(e => e)) || [];\n        message.enemy5ks = ((_s = object.enemy5ks) === null || _s === void 0 ? void 0 : _s.map(e => e)) || [];\n        message.mvps = ((_t = object.mvps) === null || _t === void 0 ? void 0 : _t.map(e => e)) || [];\n        message.spectatorsCount = (_u = object.spectatorsCount) !== null && _u !== void 0 ? _u : 0;\n        message.spectatorsCountTv = (_v = object.spectatorsCountTv) !== null && _v !== void 0 ? _v : 0;\n        message.spectatorsCountLnk = (_w = object.spectatorsCountLnk) !== null && _w !== void 0 ? _w : 0;\n        message.enemyKillsAgg = ((_x = object.enemyKillsAgg) === null || _x === void 0 ? void 0 : _x.map(e => e)) || [];\n        message.dropInfo =\n            object.dropInfo !== undefined && object.dropInfo !== null\n                ? exports.CMsgGCCStrike15V2MatchmakingServerRoundStats_DropInfo.fromPartial(object.dropInfo)\n                : undefined;\n        message.bSwitchedTeams = (_y = object.bSwitchedTeams) !== null && _y !== void 0 ? _y : false;\n        message.enemy2ks = ((_z = object.enemy2ks) === null || _z === void 0 ? void 0 : _z.map(e => e)) || [];\n        message.playerSpawned = ((_0 = object.playerSpawned) === null || _0 === void 0 ? void 0 : _0.map(e => e)) || [];\n        message.teamSpawnCount = ((_1 = object.teamSpawnCount) === null || _1 === void 0 ? void 0 : _1.map(e => e)) || [];\n        message.maxRounds = (_2 = object.maxRounds) !== null && _2 !== void 0 ? _2 : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchmakingServerRoundStats_DropInfo() {\n    return { accountMvp: 0 };\n}\nexports.CMsgGCCStrike15V2MatchmakingServerRoundStats_DropInfo = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountMvp !== 0) {\n            writer.uint32(8).uint32(message.accountMvp);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingServerRoundStats_DropInfo();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountMvp = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingServerRoundStats_DropInfo();\n        message.accountMvp = (_a = object.accountMvp) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchmakingClient2GCHello() {\n    return {};\n}\nexports.CMsgGCCStrike15V2MatchmakingClient2GCHello = {\n    encode(_, writer = minimal_1.Writer.create()) {\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingClient2GCHello();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(_) {\n        const message = createBaseCMsgGCCStrike15V2MatchmakingClient2GCHello();\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchmakingGC2ClientHello() {\n    return {\n        accountId: 0,\n        ongoingmatch: undefined,\n        globalStats: undefined,\n        penaltySeconds: 0,\n        penaltyReason: 0,\n        vacBanned: 0,\n        ranking: undefined,\n        commendation: undefined,\n        medals: undefined,\n        myCurrentEvent: undefined,\n        myCurrentEventTeams: [],\n        myCurrentTeam: undefined,\n        myCurrentEventStages: [],\n        surveyVote: 0,\n        activity: undefined,\n        playerLevel: 0,\n        playerCurXp: 0,\n        playerXpBonusFlags: 0,\n        rankings: []\n    };\n}\nexports.CMsgGCCStrike15V2MatchmakingGC2ClientHello = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountId !== 0) {\n            writer.uint32(8).uint32(message.accountId);\n        }\n        if (message.ongoingmatch !== undefined) {\n            exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.encode(message.ongoingmatch, writer.uint32(18).fork()).ldelim();\n        }\n        if (message.globalStats !== undefined) {\n            exports.GlobalStatistics.encode(message.globalStats, writer.uint32(26).fork()).ldelim();\n        }\n        if (message.penaltySeconds !== 0) {\n            writer.uint32(32).uint32(message.penaltySeconds);\n        }\n        if (message.penaltyReason !== 0) {\n            writer.uint32(40).uint32(message.penaltyReason);\n        }\n        if (message.vacBanned !== 0) {\n            writer.uint32(48).int32(message.vacBanned);\n        }\n        if (message.ranking !== undefined) {\n            exports.PlayerRankingInfo.encode(message.ranking, writer.uint32(58).fork()).ldelim();\n        }\n        if (message.commendation !== undefined) {\n            exports.PlayerCommendationInfo.encode(message.commendation, writer.uint32(66).fork()).ldelim();\n        }\n        if (message.medals !== undefined) {\n            exports.PlayerMedalsInfo.encode(message.medals, writer.uint32(74).fork()).ldelim();\n        }\n        if (message.myCurrentEvent !== undefined) {\n            exports.TournamentEvent.encode(message.myCurrentEvent, writer.uint32(82).fork()).ldelim();\n        }\n        for (const v of message.myCurrentEventTeams) {\n            exports.TournamentTeam.encode(v, writer.uint32(90).fork()).ldelim();\n        }\n        if (message.myCurrentTeam !== undefined) {\n            exports.TournamentTeam.encode(message.myCurrentTeam, writer.uint32(98).fork()).ldelim();\n        }\n        for (const v of message.myCurrentEventStages) {\n            exports.TournamentEvent.encode(v, writer.uint32(106).fork()).ldelim();\n        }\n        if (message.surveyVote !== 0) {\n            writer.uint32(112).uint32(message.surveyVote);\n        }\n        if (message.activity !== undefined) {\n            exports.AccountActivity.encode(message.activity, writer.uint32(122).fork()).ldelim();\n        }\n        if (message.playerLevel !== 0) {\n            writer.uint32(136).int32(message.playerLevel);\n        }\n        if (message.playerCurXp !== 0) {\n            writer.uint32(144).int32(message.playerCurXp);\n        }\n        if (message.playerXpBonusFlags !== 0) {\n            writer.uint32(152).int32(message.playerXpBonusFlags);\n        }\n        for (const v of message.rankings) {\n            exports.PlayerRankingInfo.encode(v, writer.uint32(162).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientHello();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountId = reader.uint32();\n                    break;\n                case 2:\n                    message.ongoingmatch =\n                        exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.decode(reader, reader.uint32());\n                    break;\n                case 3:\n                    message.globalStats = exports.GlobalStatistics.decode(reader, reader.uint32());\n                    break;\n                case 4:\n                    message.penaltySeconds = reader.uint32();\n                    break;\n                case 5:\n                    message.penaltyReason = reader.uint32();\n                    break;\n                case 6:\n                    message.vacBanned = reader.int32();\n                    break;\n                case 7:\n                    message.ranking = exports.PlayerRankingInfo.decode(reader, reader.uint32());\n                    break;\n                case 8:\n                    message.commendation = exports.PlayerCommendationInfo.decode(reader, reader.uint32());\n                    break;\n                case 9:\n                    message.medals = exports.PlayerMedalsInfo.decode(reader, reader.uint32());\n                    break;\n                case 10:\n                    message.myCurrentEvent = exports.TournamentEvent.decode(reader, reader.uint32());\n                    break;\n                case 11:\n                    message.myCurrentEventTeams.push(exports.TournamentTeam.decode(reader, reader.uint32()));\n                    break;\n                case 12:\n                    message.myCurrentTeam = exports.TournamentTeam.decode(reader, reader.uint32());\n                    break;\n                case 13:\n                    message.myCurrentEventStages.push(exports.TournamentEvent.decode(reader, reader.uint32()));\n                    break;\n                case 14:\n                    message.surveyVote = reader.uint32();\n                    break;\n                case 15:\n                    message.activity = exports.AccountActivity.decode(reader, reader.uint32());\n                    break;\n                case 17:\n                    message.playerLevel = reader.int32();\n                    break;\n                case 18:\n                    message.playerCurXp = reader.int32();\n                    break;\n                case 19:\n                    message.playerXpBonusFlags = reader.int32();\n                    break;\n                case 20:\n                    message.rankings.push(exports.PlayerRankingInfo.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientHello();\n        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;\n        message.ongoingmatch =\n            object.ongoingmatch !== undefined && object.ongoingmatch !== null\n                ? exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.fromPartial(object.ongoingmatch)\n                : undefined;\n        message.globalStats =\n            object.globalStats !== undefined && object.globalStats !== null\n                ? exports.GlobalStatistics.fromPartial(object.globalStats)\n                : undefined;\n        message.penaltySeconds = (_b = object.penaltySeconds) !== null && _b !== void 0 ? _b : 0;\n        message.penaltyReason = (_c = object.penaltyReason) !== null && _c !== void 0 ? _c : 0;\n        message.vacBanned = (_d = object.vacBanned) !== null && _d !== void 0 ? _d : 0;\n        message.ranking =\n            object.ranking !== undefined && object.ranking !== null\n                ? exports.PlayerRankingInfo.fromPartial(object.ranking)\n                : undefined;\n        message.commendation =\n            object.commendation !== undefined && object.commendation !== null\n                ? exports.PlayerCommendationInfo.fromPartial(object.commendation)\n                : undefined;\n        message.medals =\n            object.medals !== undefined && object.medals !== null\n                ? exports.PlayerMedalsInfo.fromPartial(object.medals)\n                : undefined;\n        message.myCurrentEvent =\n            object.myCurrentEvent !== undefined && object.myCurrentEvent !== null\n                ? exports.TournamentEvent.fromPartial(object.myCurrentEvent)\n                : undefined;\n        message.myCurrentEventTeams =\n            ((_e = object.myCurrentEventTeams) === null || _e === void 0 ? void 0 : _e.map(e => exports.TournamentTeam.fromPartial(e))) || [];\n        message.myCurrentTeam =\n            object.myCurrentTeam !== undefined && object.myCurrentTeam !== null\n                ? exports.TournamentTeam.fromPartial(object.myCurrentTeam)\n                : undefined;\n        message.myCurrentEventStages =\n            ((_f = object.myCurrentEventStages) === null || _f === void 0 ? void 0 : _f.map(e => exports.TournamentEvent.fromPartial(e))) ||\n                [];\n        message.surveyVote = (_g = object.surveyVote) !== null && _g !== void 0 ? _g : 0;\n        message.activity =\n            object.activity !== undefined && object.activity !== null\n                ? exports.AccountActivity.fromPartial(object.activity)\n                : undefined;\n        message.playerLevel = (_h = object.playerLevel) !== null && _h !== void 0 ? _h : 0;\n        message.playerCurXp = (_j = object.playerCurXp) !== null && _j !== void 0 ? _j : 0;\n        message.playerXpBonusFlags = (_k = object.playerXpBonusFlags) !== null && _k !== void 0 ? _k : 0;\n        message.rankings =\n            ((_l = object.rankings) === null || _l === void 0 ? void 0 : _l.map(e => exports.PlayerRankingInfo.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2AccountPrivacySettings() {\n    return { settings: [] };\n}\nexports.CMsgGCCStrike15V2AccountPrivacySettings = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.settings) {\n            exports.CMsgGCCStrike15V2AccountPrivacySettings_Setting.encode(v, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2AccountPrivacySettings();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.settings.push(exports.CMsgGCCStrike15V2AccountPrivacySettings_Setting.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2AccountPrivacySettings();\n        message.settings =\n            ((_a = object.settings) === null || _a === void 0 ? void 0 : _a.map(e => exports.CMsgGCCStrike15V2AccountPrivacySettings_Setting.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2AccountPrivacySettings_Setting() {\n    return { settingType: 0, settingValue: 0 };\n}\nexports.CMsgGCCStrike15V2AccountPrivacySettings_Setting = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.settingType !== 0) {\n            writer.uint32(8).uint32(message.settingType);\n        }\n        if (message.settingValue !== 0) {\n            writer.uint32(16).uint32(message.settingValue);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2AccountPrivacySettings_Setting();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.settingType = reader.uint32();\n                    break;\n                case 2:\n                    message.settingValue = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2AccountPrivacySettings_Setting();\n        message.settingType = (_a = object.settingType) !== null && _a !== void 0 ? _a : 0;\n        message.settingValue = (_b = object.settingValue) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchmakingGC2ClientAbandon() {\n    return {\n        accountId: 0,\n        abandonedMatch: undefined,\n        penaltySeconds: 0,\n        penaltyReason: 0\n    };\n}\nexports.CMsgGCCStrike15V2MatchmakingGC2ClientAbandon = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountId !== 0) {\n            writer.uint32(8).uint32(message.accountId);\n        }\n        if (message.abandonedMatch !== undefined) {\n            exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.encode(message.abandonedMatch, writer.uint32(18).fork()).ldelim();\n        }\n        if (message.penaltySeconds !== 0) {\n            writer.uint32(24).uint32(message.penaltySeconds);\n        }\n        if (message.penaltyReason !== 0) {\n            writer.uint32(32).uint32(message.penaltyReason);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientAbandon();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountId = reader.uint32();\n                    break;\n                case 2:\n                    message.abandonedMatch =\n                        exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.decode(reader, reader.uint32());\n                    break;\n                case 3:\n                    message.penaltySeconds = reader.uint32();\n                    break;\n                case 4:\n                    message.penaltyReason = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingGC2ClientAbandon();\n        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;\n        message.abandonedMatch =\n            object.abandonedMatch !== undefined && object.abandonedMatch !== null\n                ? exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.fromPartial(object.abandonedMatch)\n                : undefined;\n        message.penaltySeconds = (_b = object.penaltySeconds) !== null && _b !== void 0 ? _b : 0;\n        message.penaltyReason = (_c = object.penaltyReason) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientGCRankUpdate() {\n    return { rankings: [] };\n}\nexports.CMsgGCCStrike15V2ClientGCRankUpdate = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.rankings) {\n            exports.PlayerRankingInfo.encode(v, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientGCRankUpdate();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.rankings.push(exports.PlayerRankingInfo.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2ClientGCRankUpdate();\n        message.rankings =\n            ((_a = object.rankings) === null || _a === void 0 ? void 0 : _a.map(e => exports.PlayerRankingInfo.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchmakingOperator2GCBlogUpdate() {\n    return { mainPostUrl: \"\" };\n}\nexports.CMsgGCCStrike15V2MatchmakingOperator2GCBlogUpdate = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.mainPostUrl !== \"\") {\n            writer.uint32(10).string(message.mainPostUrl);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingOperator2GCBlogUpdate();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.mainPostUrl = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2MatchmakingOperator2GCBlogUpdate();\n        message.mainPostUrl = (_a = object.mainPostUrl) !== null && _a !== void 0 ? _a : \"\";\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ServerNotificationForUserPenalty() {\n    return { accountId: 0, reason: 0, seconds: 0, communicationCooldown: false };\n}\nexports.CMsgGCCStrike15V2ServerNotificationForUserPenalty = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountId !== 0) {\n            writer.uint32(8).uint32(message.accountId);\n        }\n        if (message.reason !== 0) {\n            writer.uint32(16).uint32(message.reason);\n        }\n        if (message.seconds !== 0) {\n            writer.uint32(24).uint32(message.seconds);\n        }\n        if (message.communicationCooldown === true) {\n            writer.uint32(32).bool(message.communicationCooldown);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ServerNotificationForUserPenalty();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountId = reader.uint32();\n                    break;\n                case 2:\n                    message.reason = reader.uint32();\n                    break;\n                case 3:\n                    message.seconds = reader.uint32();\n                    break;\n                case 4:\n                    message.communicationCooldown = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCMsgGCCStrike15V2ServerNotificationForUserPenalty();\n        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;\n        message.reason = (_b = object.reason) !== null && _b !== void 0 ? _b : 0;\n        message.seconds = (_c = object.seconds) !== null && _c !== void 0 ? _c : 0;\n        message.communicationCooldown = (_d = object.communicationCooldown) !== null && _d !== void 0 ? _d : false;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientReportPlayer() {\n    return {\n        accountId: 0,\n        rptAimbot: 0,\n        rptWallhack: 0,\n        rptSpeedhack: 0,\n        rptTeamharm: 0,\n        rptTextabuse: 0,\n        rptVoiceabuse: 0,\n        matchId: Long.UZERO,\n        reportFromDemo: false\n    };\n}\nexports.CMsgGCCStrike15V2ClientReportPlayer = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountId !== 0) {\n            writer.uint32(8).uint32(message.accountId);\n        }\n        if (message.rptAimbot !== 0) {\n            writer.uint32(16).uint32(message.rptAimbot);\n        }\n        if (message.rptWallhack !== 0) {\n            writer.uint32(24).uint32(message.rptWallhack);\n        }\n        if (message.rptSpeedhack !== 0) {\n            writer.uint32(32).uint32(message.rptSpeedhack);\n        }\n        if (message.rptTeamharm !== 0) {\n            writer.uint32(40).uint32(message.rptTeamharm);\n        }\n        if (message.rptTextabuse !== 0) {\n            writer.uint32(48).uint32(message.rptTextabuse);\n        }\n        if (message.rptVoiceabuse !== 0) {\n            writer.uint32(56).uint32(message.rptVoiceabuse);\n        }\n        if (!message.matchId.isZero()) {\n            writer.uint32(64).uint64(message.matchId);\n        }\n        if (message.reportFromDemo === true) {\n            writer.uint32(72).bool(message.reportFromDemo);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientReportPlayer();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountId = reader.uint32();\n                    break;\n                case 2:\n                    message.rptAimbot = reader.uint32();\n                    break;\n                case 3:\n                    message.rptWallhack = reader.uint32();\n                    break;\n                case 4:\n                    message.rptSpeedhack = reader.uint32();\n                    break;\n                case 5:\n                    message.rptTeamharm = reader.uint32();\n                    break;\n                case 6:\n                    message.rptTextabuse = reader.uint32();\n                    break;\n                case 7:\n                    message.rptVoiceabuse = reader.uint32();\n                    break;\n                case 8:\n                    message.matchId = reader.uint64();\n                    break;\n                case 9:\n                    message.reportFromDemo = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h;\n        const message = createBaseCMsgGCCStrike15V2ClientReportPlayer();\n        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;\n        message.rptAimbot = (_b = object.rptAimbot) !== null && _b !== void 0 ? _b : 0;\n        message.rptWallhack = (_c = object.rptWallhack) !== null && _c !== void 0 ? _c : 0;\n        message.rptSpeedhack = (_d = object.rptSpeedhack) !== null && _d !== void 0 ? _d : 0;\n        message.rptTeamharm = (_e = object.rptTeamharm) !== null && _e !== void 0 ? _e : 0;\n        message.rptTextabuse = (_f = object.rptTextabuse) !== null && _f !== void 0 ? _f : 0;\n        message.rptVoiceabuse = (_g = object.rptVoiceabuse) !== null && _g !== void 0 ? _g : 0;\n        message.matchId =\n            object.matchId !== undefined && object.matchId !== null\n                ? Long.fromValue(object.matchId)\n                : Long.UZERO;\n        message.reportFromDemo = (_h = object.reportFromDemo) !== null && _h !== void 0 ? _h : false;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientCommendPlayer() {\n    return {\n        accountId: 0,\n        matchId: Long.UZERO,\n        commendation: undefined,\n        tokens: 0\n    };\n}\nexports.CMsgGCCStrike15V2ClientCommendPlayer = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountId !== 0) {\n            writer.uint32(8).uint32(message.accountId);\n        }\n        if (!message.matchId.isZero()) {\n            writer.uint32(64).uint64(message.matchId);\n        }\n        if (message.commendation !== undefined) {\n            exports.PlayerCommendationInfo.encode(message.commendation, writer.uint32(74).fork()).ldelim();\n        }\n        if (message.tokens !== 0) {\n            writer.uint32(80).uint32(message.tokens);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientCommendPlayer();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountId = reader.uint32();\n                    break;\n                case 8:\n                    message.matchId = reader.uint64();\n                    break;\n                case 9:\n                    message.commendation = exports.PlayerCommendationInfo.decode(reader, reader.uint32());\n                    break;\n                case 10:\n                    message.tokens = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2ClientCommendPlayer();\n        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;\n        message.matchId =\n            object.matchId !== undefined && object.matchId !== null\n                ? Long.fromValue(object.matchId)\n                : Long.UZERO;\n        message.commendation =\n            object.commendation !== undefined && object.commendation !== null\n                ? exports.PlayerCommendationInfo.fromPartial(object.commendation)\n                : undefined;\n        message.tokens = (_b = object.tokens) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientReportServer() {\n    return {\n        rptPoorperf: 0,\n        rptAbusivemodels: 0,\n        rptBadmotd: 0,\n        rptListingabuse: 0,\n        rptInventoryabuse: 0,\n        matchId: Long.UZERO\n    };\n}\nexports.CMsgGCCStrike15V2ClientReportServer = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.rptPoorperf !== 0) {\n            writer.uint32(8).uint32(message.rptPoorperf);\n        }\n        if (message.rptAbusivemodels !== 0) {\n            writer.uint32(16).uint32(message.rptAbusivemodels);\n        }\n        if (message.rptBadmotd !== 0) {\n            writer.uint32(24).uint32(message.rptBadmotd);\n        }\n        if (message.rptListingabuse !== 0) {\n            writer.uint32(32).uint32(message.rptListingabuse);\n        }\n        if (message.rptInventoryabuse !== 0) {\n            writer.uint32(40).uint32(message.rptInventoryabuse);\n        }\n        if (!message.matchId.isZero()) {\n            writer.uint32(64).uint64(message.matchId);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientReportServer();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.rptPoorperf = reader.uint32();\n                    break;\n                case 2:\n                    message.rptAbusivemodels = reader.uint32();\n                    break;\n                case 3:\n                    message.rptBadmotd = reader.uint32();\n                    break;\n                case 4:\n                    message.rptListingabuse = reader.uint32();\n                    break;\n                case 5:\n                    message.rptInventoryabuse = reader.uint32();\n                    break;\n                case 8:\n                    message.matchId = reader.uint64();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseCMsgGCCStrike15V2ClientReportServer();\n        message.rptPoorperf = (_a = object.rptPoorperf) !== null && _a !== void 0 ? _a : 0;\n        message.rptAbusivemodels = (_b = object.rptAbusivemodels) !== null && _b !== void 0 ? _b : 0;\n        message.rptBadmotd = (_c = object.rptBadmotd) !== null && _c !== void 0 ? _c : 0;\n        message.rptListingabuse = (_d = object.rptListingabuse) !== null && _d !== void 0 ? _d : 0;\n        message.rptInventoryabuse = (_e = object.rptInventoryabuse) !== null && _e !== void 0 ? _e : 0;\n        message.matchId =\n            object.matchId !== undefined && object.matchId !== null\n                ? Long.fromValue(object.matchId)\n                : Long.UZERO;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientReportResponse() {\n    return {\n        confirmationId: Long.UZERO,\n        accountId: 0,\n        serverIp: 0,\n        responseType: 0,\n        responseResult: 0,\n        tokens: 0\n    };\n}\nexports.CMsgGCCStrike15V2ClientReportResponse = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.confirmationId.isZero()) {\n            writer.uint32(8).uint64(message.confirmationId);\n        }\n        if (message.accountId !== 0) {\n            writer.uint32(16).uint32(message.accountId);\n        }\n        if (message.serverIp !== 0) {\n            writer.uint32(24).uint32(message.serverIp);\n        }\n        if (message.responseType !== 0) {\n            writer.uint32(32).uint32(message.responseType);\n        }\n        if (message.responseResult !== 0) {\n            writer.uint32(40).uint32(message.responseResult);\n        }\n        if (message.tokens !== 0) {\n            writer.uint32(48).uint32(message.tokens);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientReportResponse();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.confirmationId = reader.uint64();\n                    break;\n                case 2:\n                    message.accountId = reader.uint32();\n                    break;\n                case 3:\n                    message.serverIp = reader.uint32();\n                    break;\n                case 4:\n                    message.responseType = reader.uint32();\n                    break;\n                case 5:\n                    message.responseResult = reader.uint32();\n                    break;\n                case 6:\n                    message.tokens = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseCMsgGCCStrike15V2ClientReportResponse();\n        message.confirmationId =\n            object.confirmationId !== undefined && object.confirmationId !== null\n                ? Long.fromValue(object.confirmationId)\n                : Long.UZERO;\n        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;\n        message.serverIp = (_b = object.serverIp) !== null && _b !== void 0 ? _b : 0;\n        message.responseType = (_c = object.responseType) !== null && _c !== void 0 ? _c : 0;\n        message.responseResult = (_d = object.responseResult) !== null && _d !== void 0 ? _d : 0;\n        message.tokens = (_e = object.tokens) !== null && _e !== void 0 ? _e : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientRequestWatchInfoFriends() {\n    return {\n        requestId: 0,\n        accountIds: [],\n        serverid: Long.UZERO,\n        matchid: Long.UZERO,\n        clientLauncher: 0,\n        dataCenterPings: []\n    };\n}\nexports.CMsgGCCStrike15V2ClientRequestWatchInfoFriends = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.requestId !== 0) {\n            writer.uint32(8).uint32(message.requestId);\n        }\n        writer.uint32(18).fork();\n        for (const v of message.accountIds) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        if (!message.serverid.isZero()) {\n            writer.uint32(24).uint64(message.serverid);\n        }\n        if (!message.matchid.isZero()) {\n            writer.uint32(32).uint64(message.matchid);\n        }\n        if (message.clientLauncher !== 0) {\n            writer.uint32(40).uint32(message.clientLauncher);\n        }\n        for (const v of message.dataCenterPings) {\n            exports.DataCenterPing.encode(v, writer.uint32(50).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientRequestWatchInfoFriends();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.requestId = reader.uint32();\n                    break;\n                case 2:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.accountIds.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.accountIds.push(reader.uint32());\n                    }\n                    break;\n                case 3:\n                    message.serverid = reader.uint64();\n                    break;\n                case 4:\n                    message.matchid = reader.uint64();\n                    break;\n                case 5:\n                    message.clientLauncher = reader.uint32();\n                    break;\n                case 6:\n                    message.dataCenterPings.push(exports.DataCenterPing.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCMsgGCCStrike15V2ClientRequestWatchInfoFriends();\n        message.requestId = (_a = object.requestId) !== null && _a !== void 0 ? _a : 0;\n        message.accountIds = ((_b = object.accountIds) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];\n        message.serverid =\n            object.serverid !== undefined && object.serverid !== null\n                ? Long.fromValue(object.serverid)\n                : Long.UZERO;\n        message.matchid =\n            object.matchid !== undefined && object.matchid !== null\n                ? Long.fromValue(object.matchid)\n                : Long.UZERO;\n        message.clientLauncher = (_c = object.clientLauncher) !== null && _c !== void 0 ? _c : 0;\n        message.dataCenterPings =\n            ((_d = object.dataCenterPings) === null || _d === void 0 ? void 0 : _d.map(e => exports.DataCenterPing.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseWatchableMatchInfo() {\n    return {\n        serverIp: 0,\n        tvPort: 0,\n        tvSpectators: 0,\n        tvTime: 0,\n        tvWatchPassword: new Uint8Array(),\n        clDecryptdataKey: Long.UZERO,\n        clDecryptdataKeyPub: Long.UZERO,\n        gameType: 0,\n        gameMapgroup: \"\",\n        gameMap: \"\",\n        serverId: Long.UZERO,\n        matchId: Long.UZERO,\n        reservationId: Long.UZERO\n    };\n}\nexports.WatchableMatchInfo = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.serverIp !== 0) {\n            writer.uint32(8).uint32(message.serverIp);\n        }\n        if (message.tvPort !== 0) {\n            writer.uint32(16).uint32(message.tvPort);\n        }\n        if (message.tvSpectators !== 0) {\n            writer.uint32(24).uint32(message.tvSpectators);\n        }\n        if (message.tvTime !== 0) {\n            writer.uint32(32).uint32(message.tvTime);\n        }\n        if (message.tvWatchPassword.length !== 0) {\n            writer.uint32(42).bytes(message.tvWatchPassword);\n        }\n        if (!message.clDecryptdataKey.isZero()) {\n            writer.uint32(48).uint64(message.clDecryptdataKey);\n        }\n        if (!message.clDecryptdataKeyPub.isZero()) {\n            writer.uint32(56).uint64(message.clDecryptdataKeyPub);\n        }\n        if (message.gameType !== 0) {\n            writer.uint32(64).uint32(message.gameType);\n        }\n        if (message.gameMapgroup !== \"\") {\n            writer.uint32(74).string(message.gameMapgroup);\n        }\n        if (message.gameMap !== \"\") {\n            writer.uint32(82).string(message.gameMap);\n        }\n        if (!message.serverId.isZero()) {\n            writer.uint32(88).uint64(message.serverId);\n        }\n        if (!message.matchId.isZero()) {\n            writer.uint32(96).uint64(message.matchId);\n        }\n        if (!message.reservationId.isZero()) {\n            writer.uint32(104).uint64(message.reservationId);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseWatchableMatchInfo();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.serverIp = reader.uint32();\n                    break;\n                case 2:\n                    message.tvPort = reader.uint32();\n                    break;\n                case 3:\n                    message.tvSpectators = reader.uint32();\n                    break;\n                case 4:\n                    message.tvTime = reader.uint32();\n                    break;\n                case 5:\n                    message.tvWatchPassword = reader.bytes();\n                    break;\n                case 6:\n                    message.clDecryptdataKey = reader.uint64();\n                    break;\n                case 7:\n                    message.clDecryptdataKeyPub = reader.uint64();\n                    break;\n                case 8:\n                    message.gameType = reader.uint32();\n                    break;\n                case 9:\n                    message.gameMapgroup = reader.string();\n                    break;\n                case 10:\n                    message.gameMap = reader.string();\n                    break;\n                case 11:\n                    message.serverId = reader.uint64();\n                    break;\n                case 12:\n                    message.matchId = reader.uint64();\n                    break;\n                case 13:\n                    message.reservationId = reader.uint64();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h;\n        const message = createBaseWatchableMatchInfo();\n        message.serverIp = (_a = object.serverIp) !== null && _a !== void 0 ? _a : 0;\n        message.tvPort = (_b = object.tvPort) !== null && _b !== void 0 ? _b : 0;\n        message.tvSpectators = (_c = object.tvSpectators) !== null && _c !== void 0 ? _c : 0;\n        message.tvTime = (_d = object.tvTime) !== null && _d !== void 0 ? _d : 0;\n        message.tvWatchPassword = (_e = object.tvWatchPassword) !== null && _e !== void 0 ? _e : new Uint8Array();\n        message.clDecryptdataKey =\n            object.clDecryptdataKey !== undefined && object.clDecryptdataKey !== null\n                ? Long.fromValue(object.clDecryptdataKey)\n                : Long.UZERO;\n        message.clDecryptdataKeyPub =\n            object.clDecryptdataKeyPub !== undefined &&\n                object.clDecryptdataKeyPub !== null\n                ? Long.fromValue(object.clDecryptdataKeyPub)\n                : Long.UZERO;\n        message.gameType = (_f = object.gameType) !== null && _f !== void 0 ? _f : 0;\n        message.gameMapgroup = (_g = object.gameMapgroup) !== null && _g !== void 0 ? _g : \"\";\n        message.gameMap = (_h = object.gameMap) !== null && _h !== void 0 ? _h : \"\";\n        message.serverId =\n            object.serverId !== undefined && object.serverId !== null\n                ? Long.fromValue(object.serverId)\n                : Long.UZERO;\n        message.matchId =\n            object.matchId !== undefined && object.matchId !== null\n                ? Long.fromValue(object.matchId)\n                : Long.UZERO;\n        message.reservationId =\n            object.reservationId !== undefined && object.reservationId !== null\n                ? Long.fromValue(object.reservationId)\n                : Long.UZERO;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientRequestJoinFriendData() {\n    return {\n        version: 0,\n        accountId: 0,\n        joinToken: 0,\n        joinIpp: 0,\n        res: undefined,\n        errormsg: \"\"\n    };\n}\nexports.CMsgGCCStrike15V2ClientRequestJoinFriendData = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.version !== 0) {\n            writer.uint32(8).uint32(message.version);\n        }\n        if (message.accountId !== 0) {\n            writer.uint32(16).uint32(message.accountId);\n        }\n        if (message.joinToken !== 0) {\n            writer.uint32(24).uint32(message.joinToken);\n        }\n        if (message.joinIpp !== 0) {\n            writer.uint32(32).uint32(message.joinIpp);\n        }\n        if (message.res !== undefined) {\n            exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.encode(message.res, writer.uint32(42).fork()).ldelim();\n        }\n        if (message.errormsg !== \"\") {\n            writer.uint32(50).string(message.errormsg);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientRequestJoinFriendData();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.version = reader.uint32();\n                    break;\n                case 2:\n                    message.accountId = reader.uint32();\n                    break;\n                case 3:\n                    message.joinToken = reader.uint32();\n                    break;\n                case 4:\n                    message.joinIpp = reader.uint32();\n                    break;\n                case 5:\n                    message.res = exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.decode(reader, reader.uint32());\n                    break;\n                case 6:\n                    message.errormsg = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseCMsgGCCStrike15V2ClientRequestJoinFriendData();\n        message.version = (_a = object.version) !== null && _a !== void 0 ? _a : 0;\n        message.accountId = (_b = object.accountId) !== null && _b !== void 0 ? _b : 0;\n        message.joinToken = (_c = object.joinToken) !== null && _c !== void 0 ? _c : 0;\n        message.joinIpp = (_d = object.joinIpp) !== null && _d !== void 0 ? _d : 0;\n        message.res =\n            object.res !== undefined && object.res !== null\n                ? exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.fromPartial(object.res)\n                : undefined;\n        message.errormsg = (_e = object.errormsg) !== null && _e !== void 0 ? _e : \"\";\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientRequestJoinServerData() {\n    return {\n        version: 0,\n        accountId: 0,\n        serverid: Long.UZERO,\n        serverIp: 0,\n        serverPort: 0,\n        res: undefined,\n        errormsg: \"\"\n    };\n}\nexports.CMsgGCCStrike15V2ClientRequestJoinServerData = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.version !== 0) {\n            writer.uint32(8).uint32(message.version);\n        }\n        if (message.accountId !== 0) {\n            writer.uint32(16).uint32(message.accountId);\n        }\n        if (!message.serverid.isZero()) {\n            writer.uint32(24).uint64(message.serverid);\n        }\n        if (message.serverIp !== 0) {\n            writer.uint32(32).uint32(message.serverIp);\n        }\n        if (message.serverPort !== 0) {\n            writer.uint32(40).uint32(message.serverPort);\n        }\n        if (message.res !== undefined) {\n            exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.encode(message.res, writer.uint32(50).fork()).ldelim();\n        }\n        if (message.errormsg !== \"\") {\n            writer.uint32(58).string(message.errormsg);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientRequestJoinServerData();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.version = reader.uint32();\n                    break;\n                case 2:\n                    message.accountId = reader.uint32();\n                    break;\n                case 3:\n                    message.serverid = reader.uint64();\n                    break;\n                case 4:\n                    message.serverIp = reader.uint32();\n                    break;\n                case 5:\n                    message.serverPort = reader.uint32();\n                    break;\n                case 6:\n                    message.res = exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.decode(reader, reader.uint32());\n                    break;\n                case 7:\n                    message.errormsg = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseCMsgGCCStrike15V2ClientRequestJoinServerData();\n        message.version = (_a = object.version) !== null && _a !== void 0 ? _a : 0;\n        message.accountId = (_b = object.accountId) !== null && _b !== void 0 ? _b : 0;\n        message.serverid =\n            object.serverid !== undefined && object.serverid !== null\n                ? Long.fromValue(object.serverid)\n                : Long.UZERO;\n        message.serverIp = (_c = object.serverIp) !== null && _c !== void 0 ? _c : 0;\n        message.serverPort = (_d = object.serverPort) !== null && _d !== void 0 ? _d : 0;\n        message.res =\n            object.res !== undefined && object.res !== null\n                ? exports.CMsgGCCStrike15V2MatchmakingGC2ClientReserve.fromPartial(object.res)\n                : undefined;\n        message.errormsg = (_e = object.errormsg) !== null && _e !== void 0 ? _e : \"\";\n        return message;\n    }\n};\nfunction createBaseCMsgGCCstrike15V2ClientRequestNewMission() {\n    return { missionId: 0, campaignId: 0 };\n}\nexports.CMsgGCCstrike15V2ClientRequestNewMission = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.missionId !== 0) {\n            writer.uint32(16).uint32(message.missionId);\n        }\n        if (message.campaignId !== 0) {\n            writer.uint32(24).uint32(message.campaignId);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCstrike15V2ClientRequestNewMission();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 2:\n                    message.missionId = reader.uint32();\n                    break;\n                case 3:\n                    message.campaignId = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCstrike15V2ClientRequestNewMission();\n        message.missionId = (_a = object.missionId) !== null && _a !== void 0 ? _a : 0;\n        message.campaignId = (_b = object.campaignId) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCstrike15V2ClientRedeemMissionReward() {\n    return { campaignId: 0, redeemId: 0, redeemableBalance: 0, expectedCost: 0 };\n}\nexports.CMsgGCCstrike15V2ClientRedeemMissionReward = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.campaignId !== 0) {\n            writer.uint32(8).uint32(message.campaignId);\n        }\n        if (message.redeemId !== 0) {\n            writer.uint32(16).uint32(message.redeemId);\n        }\n        if (message.redeemableBalance !== 0) {\n            writer.uint32(24).uint32(message.redeemableBalance);\n        }\n        if (message.expectedCost !== 0) {\n            writer.uint32(32).uint32(message.expectedCost);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCstrike15V2ClientRedeemMissionReward();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.campaignId = reader.uint32();\n                    break;\n                case 2:\n                    message.redeemId = reader.uint32();\n                    break;\n                case 3:\n                    message.redeemableBalance = reader.uint32();\n                    break;\n                case 4:\n                    message.expectedCost = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCMsgGCCstrike15V2ClientRedeemMissionReward();\n        message.campaignId = (_a = object.campaignId) !== null && _a !== void 0 ? _a : 0;\n        message.redeemId = (_b = object.redeemId) !== null && _b !== void 0 ? _b : 0;\n        message.redeemableBalance = (_c = object.redeemableBalance) !== null && _c !== void 0 ? _c : 0;\n        message.expectedCost = (_d = object.expectedCost) !== null && _d !== void 0 ? _d : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCstrike15V2GC2ServerNotifyXPRewarded() {\n    return {\n        xpProgressData: [],\n        accountId: 0,\n        currentXp: 0,\n        currentLevel: 0,\n        upgradedDefidx: 0,\n        operationPointsAwarded: 0\n    };\n}\nexports.CMsgGCCstrike15V2GC2ServerNotifyXPRewarded = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.xpProgressData) {\n            exports.XpProgressData.encode(v, writer.uint32(10).fork()).ldelim();\n        }\n        if (message.accountId !== 0) {\n            writer.uint32(16).uint32(message.accountId);\n        }\n        if (message.currentXp !== 0) {\n            writer.uint32(24).uint32(message.currentXp);\n        }\n        if (message.currentLevel !== 0) {\n            writer.uint32(32).uint32(message.currentLevel);\n        }\n        if (message.upgradedDefidx !== 0) {\n            writer.uint32(40).uint32(message.upgradedDefidx);\n        }\n        if (message.operationPointsAwarded !== 0) {\n            writer.uint32(48).uint32(message.operationPointsAwarded);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCstrike15V2GC2ServerNotifyXPRewarded();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.xpProgressData.push(exports.XpProgressData.decode(reader, reader.uint32()));\n                    break;\n                case 2:\n                    message.accountId = reader.uint32();\n                    break;\n                case 3:\n                    message.currentXp = reader.uint32();\n                    break;\n                case 4:\n                    message.currentLevel = reader.uint32();\n                    break;\n                case 5:\n                    message.upgradedDefidx = reader.uint32();\n                    break;\n                case 6:\n                    message.operationPointsAwarded = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f;\n        const message = createBaseCMsgGCCstrike15V2GC2ServerNotifyXPRewarded();\n        message.xpProgressData =\n            ((_a = object.xpProgressData) === null || _a === void 0 ? void 0 : _a.map(e => exports.XpProgressData.fromPartial(e))) || [];\n        message.accountId = (_b = object.accountId) !== null && _b !== void 0 ? _b : 0;\n        message.currentXp = (_c = object.currentXp) !== null && _c !== void 0 ? _c : 0;\n        message.currentLevel = (_d = object.currentLevel) !== null && _d !== void 0 ? _d : 0;\n        message.upgradedDefidx = (_e = object.upgradedDefidx) !== null && _e !== void 0 ? _e : 0;\n        message.operationPointsAwarded = (_f = object.operationPointsAwarded) !== null && _f !== void 0 ? _f : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15ClientDeepStats() {\n    return { accountId: 0, range: undefined, matches: [] };\n}\nexports.CMsgGCCStrike15ClientDeepStats = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountId !== 0) {\n            writer.uint32(8).uint32(message.accountId);\n        }\n        if (message.range !== undefined) {\n            exports.CMsgGCCStrike15ClientDeepStats_DeepStatsRange.encode(message.range, writer.uint32(18).fork()).ldelim();\n        }\n        for (const v of message.matches) {\n            exports.CMsgGCCStrike15ClientDeepStats_DeepStatsMatch.encode(v, writer.uint32(26).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15ClientDeepStats();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountId = reader.uint32();\n                    break;\n                case 2:\n                    message.range = exports.CMsgGCCStrike15ClientDeepStats_DeepStatsRange.decode(reader, reader.uint32());\n                    break;\n                case 3:\n                    message.matches.push(exports.CMsgGCCStrike15ClientDeepStats_DeepStatsMatch.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15ClientDeepStats();\n        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;\n        message.range =\n            object.range !== undefined && object.range !== null\n                ? exports.CMsgGCCStrike15ClientDeepStats_DeepStatsRange.fromPartial(object.range)\n                : undefined;\n        message.matches =\n            ((_b = object.matches) === null || _b === void 0 ? void 0 : _b.map(e => exports.CMsgGCCStrike15ClientDeepStats_DeepStatsMatch.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15ClientDeepStats_DeepStatsRange() {\n    return { begin: 0, end: 0, frozen: false };\n}\nexports.CMsgGCCStrike15ClientDeepStats_DeepStatsRange = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.begin !== 0) {\n            writer.uint32(8).uint32(message.begin);\n        }\n        if (message.end !== 0) {\n            writer.uint32(16).uint32(message.end);\n        }\n        if (message.frozen === true) {\n            writer.uint32(24).bool(message.frozen);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15ClientDeepStats_DeepStatsRange();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.begin = reader.uint32();\n                    break;\n                case 2:\n                    message.end = reader.uint32();\n                    break;\n                case 3:\n                    message.frozen = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCMsgGCCStrike15ClientDeepStats_DeepStatsRange();\n        message.begin = (_a = object.begin) !== null && _a !== void 0 ? _a : 0;\n        message.end = (_b = object.end) !== null && _b !== void 0 ? _b : 0;\n        message.frozen = (_c = object.frozen) !== null && _c !== void 0 ? _c : false;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15ClientDeepStats_DeepStatsMatch() {\n    return { player: undefined, events: [] };\n}\nexports.CMsgGCCStrike15ClientDeepStats_DeepStatsMatch = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.player !== undefined) {\n            exports.DeepPlayerStatsEntry.encode(message.player, writer.uint32(10).fork()).ldelim();\n        }\n        for (const v of message.events) {\n            exports.DeepPlayerMatchEvent.encode(v, writer.uint32(18).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15ClientDeepStats_DeepStatsMatch();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.player = exports.DeepPlayerStatsEntry.decode(reader, reader.uint32());\n                    break;\n                case 2:\n                    message.events.push(exports.DeepPlayerMatchEvent.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15ClientDeepStats_DeepStatsMatch();\n        message.player =\n            object.player !== undefined && object.player !== null\n                ? exports.DeepPlayerStatsEntry.fromPartial(object.player)\n                : undefined;\n        message.events =\n            ((_a = object.events) === null || _a === void 0 ? void 0 : _a.map(e => exports.DeepPlayerMatchEvent.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2WatchInfoUsers() {\n    return {\n        requestId: 0,\n        accountIds: [],\n        watchableMatchInfos: [],\n        extendedTimeout: 0\n    };\n}\nexports.CMsgGCCStrike15V2WatchInfoUsers = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.requestId !== 0) {\n            writer.uint32(8).uint32(message.requestId);\n        }\n        writer.uint32(18).fork();\n        for (const v of message.accountIds) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        for (const v of message.watchableMatchInfos) {\n            exports.WatchableMatchInfo.encode(v, writer.uint32(26).fork()).ldelim();\n        }\n        if (message.extendedTimeout !== 0) {\n            writer.uint32(40).uint32(message.extendedTimeout);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2WatchInfoUsers();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.requestId = reader.uint32();\n                    break;\n                case 2:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.accountIds.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.accountIds.push(reader.uint32());\n                    }\n                    break;\n                case 3:\n                    message.watchableMatchInfos.push(exports.WatchableMatchInfo.decode(reader, reader.uint32()));\n                    break;\n                case 5:\n                    message.extendedTimeout = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCMsgGCCStrike15V2WatchInfoUsers();\n        message.requestId = (_a = object.requestId) !== null && _a !== void 0 ? _a : 0;\n        message.accountIds = ((_b = object.accountIds) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];\n        message.watchableMatchInfos =\n            ((_c = object.watchableMatchInfos) === null || _c === void 0 ? void 0 : _c.map(e => exports.WatchableMatchInfo.fromPartial(e))) ||\n                [];\n        message.extendedTimeout = (_d = object.extendedTimeout) !== null && _d !== void 0 ? _d : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientRequestPlayersProfile() {\n    return {\n        requestIdDeprecated: 0,\n        accountIdsDeprecated: [],\n        accountId: 0,\n        requestLevel: 0\n    };\n}\nexports.CMsgGCCStrike15V2ClientRequestPlayersProfile = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.requestIdDeprecated !== 0) {\n            writer.uint32(8).uint32(message.requestIdDeprecated);\n        }\n        writer.uint32(18).fork();\n        for (const v of message.accountIdsDeprecated) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        if (message.accountId !== 0) {\n            writer.uint32(24).uint32(message.accountId);\n        }\n        if (message.requestLevel !== 0) {\n            writer.uint32(32).uint32(message.requestLevel);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientRequestPlayersProfile();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.requestIdDeprecated = reader.uint32();\n                    break;\n                case 2:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.accountIdsDeprecated.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.accountIdsDeprecated.push(reader.uint32());\n                    }\n                    break;\n                case 3:\n                    message.accountId = reader.uint32();\n                    break;\n                case 4:\n                    message.requestLevel = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCMsgGCCStrike15V2ClientRequestPlayersProfile();\n        message.requestIdDeprecated = (_a = object.requestIdDeprecated) !== null && _a !== void 0 ? _a : 0;\n        message.accountIdsDeprecated =\n            ((_b = object.accountIdsDeprecated) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];\n        message.accountId = (_c = object.accountId) !== null && _c !== void 0 ? _c : 0;\n        message.requestLevel = (_d = object.requestLevel) !== null && _d !== void 0 ? _d : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2PlayersProfile() {\n    return { requestId: 0, accountProfiles: [] };\n}\nexports.CMsgGCCStrike15V2PlayersProfile = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.requestId !== 0) {\n            writer.uint32(8).uint32(message.requestId);\n        }\n        for (const v of message.accountProfiles) {\n            exports.CMsgGCCStrike15V2MatchmakingGC2ClientHello.encode(v, writer.uint32(18).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2PlayersProfile();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.requestId = reader.uint32();\n                    break;\n                case 2:\n                    message.accountProfiles.push(exports.CMsgGCCStrike15V2MatchmakingGC2ClientHello.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2PlayersProfile();\n        message.requestId = (_a = object.requestId) !== null && _a !== void 0 ? _a : 0;\n        message.accountProfiles =\n            ((_b = object.accountProfiles) === null || _b === void 0 ? void 0 : _b.map(e => exports.CMsgGCCStrike15V2MatchmakingGC2ClientHello.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2PlayerOverwatchCaseUpdate() {\n    return {\n        caseid: Long.UZERO,\n        suspectid: 0,\n        fractionid: 0,\n        rptAimbot: 0,\n        rptWallhack: 0,\n        rptSpeedhack: 0,\n        rptTeamharm: 0,\n        reason: 0\n    };\n}\nexports.CMsgGCCStrike15V2PlayerOverwatchCaseUpdate = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.caseid.isZero()) {\n            writer.uint32(8).uint64(message.caseid);\n        }\n        if (message.suspectid !== 0) {\n            writer.uint32(24).uint32(message.suspectid);\n        }\n        if (message.fractionid !== 0) {\n            writer.uint32(32).uint32(message.fractionid);\n        }\n        if (message.rptAimbot !== 0) {\n            writer.uint32(40).uint32(message.rptAimbot);\n        }\n        if (message.rptWallhack !== 0) {\n            writer.uint32(48).uint32(message.rptWallhack);\n        }\n        if (message.rptSpeedhack !== 0) {\n            writer.uint32(56).uint32(message.rptSpeedhack);\n        }\n        if (message.rptTeamharm !== 0) {\n            writer.uint32(64).uint32(message.rptTeamharm);\n        }\n        if (message.reason !== 0) {\n            writer.uint32(72).uint32(message.reason);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2PlayerOverwatchCaseUpdate();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.caseid = reader.uint64();\n                    break;\n                case 3:\n                    message.suspectid = reader.uint32();\n                    break;\n                case 4:\n                    message.fractionid = reader.uint32();\n                    break;\n                case 5:\n                    message.rptAimbot = reader.uint32();\n                    break;\n                case 6:\n                    message.rptWallhack = reader.uint32();\n                    break;\n                case 7:\n                    message.rptSpeedhack = reader.uint32();\n                    break;\n                case 8:\n                    message.rptTeamharm = reader.uint32();\n                    break;\n                case 9:\n                    message.reason = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g;\n        const message = createBaseCMsgGCCStrike15V2PlayerOverwatchCaseUpdate();\n        message.caseid =\n            object.caseid !== undefined && object.caseid !== null\n                ? Long.fromValue(object.caseid)\n                : Long.UZERO;\n        message.suspectid = (_a = object.suspectid) !== null && _a !== void 0 ? _a : 0;\n        message.fractionid = (_b = object.fractionid) !== null && _b !== void 0 ? _b : 0;\n        message.rptAimbot = (_c = object.rptAimbot) !== null && _c !== void 0 ? _c : 0;\n        message.rptWallhack = (_d = object.rptWallhack) !== null && _d !== void 0 ? _d : 0;\n        message.rptSpeedhack = (_e = object.rptSpeedhack) !== null && _e !== void 0 ? _e : 0;\n        message.rptTeamharm = (_f = object.rptTeamharm) !== null && _f !== void 0 ? _f : 0;\n        message.reason = (_g = object.reason) !== null && _g !== void 0 ? _g : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2PlayerOverwatchCaseAssignment() {\n    return {\n        caseid: Long.UZERO,\n        caseurl: \"\",\n        verdict: 0,\n        timestamp: 0,\n        throttleseconds: 0,\n        suspectid: 0,\n        fractionid: 0,\n        numrounds: 0,\n        fractionrounds: 0,\n        streakconvictions: 0,\n        reason: 0\n    };\n}\nexports.CMsgGCCStrike15V2PlayerOverwatchCaseAssignment = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.caseid.isZero()) {\n            writer.uint32(8).uint64(message.caseid);\n        }\n        if (message.caseurl !== \"\") {\n            writer.uint32(18).string(message.caseurl);\n        }\n        if (message.verdict !== 0) {\n            writer.uint32(24).uint32(message.verdict);\n        }\n        if (message.timestamp !== 0) {\n            writer.uint32(32).uint32(message.timestamp);\n        }\n        if (message.throttleseconds !== 0) {\n            writer.uint32(40).uint32(message.throttleseconds);\n        }\n        if (message.suspectid !== 0) {\n            writer.uint32(48).uint32(message.suspectid);\n        }\n        if (message.fractionid !== 0) {\n            writer.uint32(56).uint32(message.fractionid);\n        }\n        if (message.numrounds !== 0) {\n            writer.uint32(64).uint32(message.numrounds);\n        }\n        if (message.fractionrounds !== 0) {\n            writer.uint32(72).uint32(message.fractionrounds);\n        }\n        if (message.streakconvictions !== 0) {\n            writer.uint32(80).int32(message.streakconvictions);\n        }\n        if (message.reason !== 0) {\n            writer.uint32(88).uint32(message.reason);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2PlayerOverwatchCaseAssignment();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.caseid = reader.uint64();\n                    break;\n                case 2:\n                    message.caseurl = reader.string();\n                    break;\n                case 3:\n                    message.verdict = reader.uint32();\n                    break;\n                case 4:\n                    message.timestamp = reader.uint32();\n                    break;\n                case 5:\n                    message.throttleseconds = reader.uint32();\n                    break;\n                case 6:\n                    message.suspectid = reader.uint32();\n                    break;\n                case 7:\n                    message.fractionid = reader.uint32();\n                    break;\n                case 8:\n                    message.numrounds = reader.uint32();\n                    break;\n                case 9:\n                    message.fractionrounds = reader.uint32();\n                    break;\n                case 10:\n                    message.streakconvictions = reader.int32();\n                    break;\n                case 11:\n                    message.reason = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;\n        const message = createBaseCMsgGCCStrike15V2PlayerOverwatchCaseAssignment();\n        message.caseid =\n            object.caseid !== undefined && object.caseid !== null\n                ? Long.fromValue(object.caseid)\n                : Long.UZERO;\n        message.caseurl = (_a = object.caseurl) !== null && _a !== void 0 ? _a : \"\";\n        message.verdict = (_b = object.verdict) !== null && _b !== void 0 ? _b : 0;\n        message.timestamp = (_c = object.timestamp) !== null && _c !== void 0 ? _c : 0;\n        message.throttleseconds = (_d = object.throttleseconds) !== null && _d !== void 0 ? _d : 0;\n        message.suspectid = (_e = object.suspectid) !== null && _e !== void 0 ? _e : 0;\n        message.fractionid = (_f = object.fractionid) !== null && _f !== void 0 ? _f : 0;\n        message.numrounds = (_g = object.numrounds) !== null && _g !== void 0 ? _g : 0;\n        message.fractionrounds = (_h = object.fractionrounds) !== null && _h !== void 0 ? _h : 0;\n        message.streakconvictions = (_j = object.streakconvictions) !== null && _j !== void 0 ? _j : 0;\n        message.reason = (_k = object.reason) !== null && _k !== void 0 ? _k : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2PlayerOverwatchCaseStatus() {\n    return { caseid: Long.UZERO, statusid: 0 };\n}\nexports.CMsgGCCStrike15V2PlayerOverwatchCaseStatus = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.caseid.isZero()) {\n            writer.uint32(8).uint64(message.caseid);\n        }\n        if (message.statusid !== 0) {\n            writer.uint32(16).uint32(message.statusid);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2PlayerOverwatchCaseStatus();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.caseid = reader.uint64();\n                    break;\n                case 2:\n                    message.statusid = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2PlayerOverwatchCaseStatus();\n        message.caseid =\n            object.caseid !== undefined && object.caseid !== null\n                ? Long.fromValue(object.caseid)\n                : Long.UZERO;\n        message.statusid = (_a = object.statusid) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCClientHeaderOverwatchEvidence() {\n    return { accountid: 0, caseid: Long.UZERO };\n}\nexports.CClientHeaderOverwatchEvidence = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountid !== 0) {\n            writer.uint32(8).uint32(message.accountid);\n        }\n        if (!message.caseid.isZero()) {\n            writer.uint32(16).uint64(message.caseid);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCClientHeaderOverwatchEvidence();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountid = reader.uint32();\n                    break;\n                case 2:\n                    message.caseid = reader.uint64();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCClientHeaderOverwatchEvidence();\n        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;\n        message.caseid =\n            object.caseid !== undefined && object.caseid !== null\n                ? Long.fromValue(object.caseid)\n                : Long.UZERO;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2GC2ClientTextMsg() {\n    return { id: 0, type: 0, payload: new Uint8Array() };\n}\nexports.CMsgGCCStrike15V2GC2ClientTextMsg = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.id !== 0) {\n            writer.uint32(8).uint32(message.id);\n        }\n        if (message.type !== 0) {\n            writer.uint32(16).uint32(message.type);\n        }\n        if (message.payload.length !== 0) {\n            writer.uint32(26).bytes(message.payload);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2GC2ClientTextMsg();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.id = reader.uint32();\n                    break;\n                case 2:\n                    message.type = reader.uint32();\n                    break;\n                case 3:\n                    message.payload = reader.bytes();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCMsgGCCStrike15V2GC2ClientTextMsg();\n        message.id = (_a = object.id) !== null && _a !== void 0 ? _a : 0;\n        message.type = (_b = object.type) !== null && _b !== void 0 ? _b : 0;\n        message.payload = (_c = object.payload) !== null && _c !== void 0 ? _c : new Uint8Array();\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2Client2GCTextMsg() {\n    return { id: 0, args: [] };\n}\nexports.CMsgGCCStrike15V2Client2GCTextMsg = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.id !== 0) {\n            writer.uint32(8).uint32(message.id);\n        }\n        for (const v of message.args) {\n            writer.uint32(18).bytes(v);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2Client2GCTextMsg();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.id = reader.uint32();\n                    break;\n                case 2:\n                    message.args.push(reader.bytes());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2Client2GCTextMsg();\n        message.id = (_a = object.id) !== null && _a !== void 0 ? _a : 0;\n        message.args = ((_b = object.args) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchEndRunRewardDrops() {\n    return { serverinfo: undefined, matchEndQuestData: undefined };\n}\nexports.CMsgGCCStrike15V2MatchEndRunRewardDrops = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.serverinfo !== undefined) {\n            exports.CMsgGCCStrike15V2MatchmakingServerReservationResponse.encode(message.serverinfo, writer.uint32(26).fork()).ldelim();\n        }\n        if (message.matchEndQuestData !== undefined) {\n            exports.CMsgGCServerQuestUpdateData.encode(message.matchEndQuestData, writer.uint32(34).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchEndRunRewardDrops();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 3:\n                    message.serverinfo =\n                        exports.CMsgGCCStrike15V2MatchmakingServerReservationResponse.decode(reader, reader.uint32());\n                    break;\n                case 4:\n                    message.matchEndQuestData = exports.CMsgGCServerQuestUpdateData.decode(reader, reader.uint32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        const message = createBaseCMsgGCCStrike15V2MatchEndRunRewardDrops();\n        message.serverinfo =\n            object.serverinfo !== undefined && object.serverinfo !== null\n                ? exports.CMsgGCCStrike15V2MatchmakingServerReservationResponse.fromPartial(object.serverinfo)\n                : undefined;\n        message.matchEndQuestData =\n            object.matchEndQuestData !== undefined &&\n                object.matchEndQuestData !== null\n                ? exports.CMsgGCServerQuestUpdateData.fromPartial(object.matchEndQuestData)\n                : undefined;\n        return message;\n    }\n};\nfunction createBaseCEconItemPreviewDataBlock() {\n    return {\n        accountid: 0,\n        itemid: Long.UZERO,\n        defindex: 0,\n        paintindex: 0,\n        rarity: 0,\n        quality: 0,\n        paintwear: 0,\n        paintseed: 0,\n        killeaterscoretype: 0,\n        killeatervalue: 0,\n        customname: \"\",\n        stickers: [],\n        inventory: 0,\n        origin: 0,\n        questid: 0,\n        dropreason: 0,\n        musicindex: 0,\n        entindex: 0\n    };\n}\nexports.CEconItemPreviewDataBlock = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountid !== 0) {\n            writer.uint32(8).uint32(message.accountid);\n        }\n        if (!message.itemid.isZero()) {\n            writer.uint32(16).uint64(message.itemid);\n        }\n        if (message.defindex !== 0) {\n            writer.uint32(24).uint32(message.defindex);\n        }\n        if (message.paintindex !== 0) {\n            writer.uint32(32).uint32(message.paintindex);\n        }\n        if (message.rarity !== 0) {\n            writer.uint32(40).uint32(message.rarity);\n        }\n        if (message.quality !== 0) {\n            writer.uint32(48).uint32(message.quality);\n        }\n        if (message.paintwear !== 0) {\n            writer.uint32(56).uint32(message.paintwear);\n        }\n        if (message.paintseed !== 0) {\n            writer.uint32(64).uint32(message.paintseed);\n        }\n        if (message.killeaterscoretype !== 0) {\n            writer.uint32(72).uint32(message.killeaterscoretype);\n        }\n        if (message.killeatervalue !== 0) {\n            writer.uint32(80).uint32(message.killeatervalue);\n        }\n        if (message.customname !== \"\") {\n            writer.uint32(90).string(message.customname);\n        }\n        for (const v of message.stickers) {\n            exports.CEconItemPreviewDataBlock_Sticker.encode(v, writer.uint32(98).fork()).ldelim();\n        }\n        if (message.inventory !== 0) {\n            writer.uint32(104).uint32(message.inventory);\n        }\n        if (message.origin !== 0) {\n            writer.uint32(112).uint32(message.origin);\n        }\n        if (message.questid !== 0) {\n            writer.uint32(120).uint32(message.questid);\n        }\n        if (message.dropreason !== 0) {\n            writer.uint32(128).uint32(message.dropreason);\n        }\n        if (message.musicindex !== 0) {\n            writer.uint32(136).uint32(message.musicindex);\n        }\n        if (message.entindex !== 0) {\n            writer.uint32(144).int32(message.entindex);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCEconItemPreviewDataBlock();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountid = reader.uint32();\n                    break;\n                case 2:\n                    message.itemid = reader.uint64();\n                    break;\n                case 3:\n                    message.defindex = reader.uint32();\n                    break;\n                case 4:\n                    message.paintindex = reader.uint32();\n                    break;\n                case 5:\n                    message.rarity = reader.uint32();\n                    break;\n                case 6:\n                    message.quality = reader.uint32();\n                    break;\n                case 7:\n                    message.paintwear = reader.uint32();\n                    break;\n                case 8:\n                    message.paintseed = reader.uint32();\n                    break;\n                case 9:\n                    message.killeaterscoretype = reader.uint32();\n                    break;\n                case 10:\n                    message.killeatervalue = reader.uint32();\n                    break;\n                case 11:\n                    message.customname = reader.string();\n                    break;\n                case 12:\n                    message.stickers.push(exports.CEconItemPreviewDataBlock_Sticker.decode(reader, reader.uint32()));\n                    break;\n                case 13:\n                    message.inventory = reader.uint32();\n                    break;\n                case 14:\n                    message.origin = reader.uint32();\n                    break;\n                case 15:\n                    message.questid = reader.uint32();\n                    break;\n                case 16:\n                    message.dropreason = reader.uint32();\n                    break;\n                case 17:\n                    message.musicindex = reader.uint32();\n                    break;\n                case 18:\n                    message.entindex = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;\n        const message = createBaseCEconItemPreviewDataBlock();\n        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;\n        message.itemid =\n            object.itemid !== undefined && object.itemid !== null\n                ? Long.fromValue(object.itemid)\n                : Long.UZERO;\n        message.defindex = (_b = object.defindex) !== null && _b !== void 0 ? _b : 0;\n        message.paintindex = (_c = object.paintindex) !== null && _c !== void 0 ? _c : 0;\n        message.rarity = (_d = object.rarity) !== null && _d !== void 0 ? _d : 0;\n        message.quality = (_e = object.quality) !== null && _e !== void 0 ? _e : 0;\n        message.paintwear = (_f = object.paintwear) !== null && _f !== void 0 ? _f : 0;\n        message.paintseed = (_g = object.paintseed) !== null && _g !== void 0 ? _g : 0;\n        message.killeaterscoretype = (_h = object.killeaterscoretype) !== null && _h !== void 0 ? _h : 0;\n        message.killeatervalue = (_j = object.killeatervalue) !== null && _j !== void 0 ? _j : 0;\n        message.customname = (_k = object.customname) !== null && _k !== void 0 ? _k : \"\";\n        message.stickers =\n            ((_l = object.stickers) === null || _l === void 0 ? void 0 : _l.map(e => exports.CEconItemPreviewDataBlock_Sticker.fromPartial(e))) || [];\n        message.inventory = (_m = object.inventory) !== null && _m !== void 0 ? _m : 0;\n        message.origin = (_o = object.origin) !== null && _o !== void 0 ? _o : 0;\n        message.questid = (_p = object.questid) !== null && _p !== void 0 ? _p : 0;\n        message.dropreason = (_q = object.dropreason) !== null && _q !== void 0 ? _q : 0;\n        message.musicindex = (_r = object.musicindex) !== null && _r !== void 0 ? _r : 0;\n        message.entindex = (_s = object.entindex) !== null && _s !== void 0 ? _s : 0;\n        return message;\n    }\n};\nfunction createBaseCEconItemPreviewDataBlock_Sticker() {\n    return { slot: 0, stickerId: 0, wear: 0, scale: 0, rotation: 0, tintId: 0 };\n}\nexports.CEconItemPreviewDataBlock_Sticker = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.slot !== 0) {\n            writer.uint32(8).uint32(message.slot);\n        }\n        if (message.stickerId !== 0) {\n            writer.uint32(16).uint32(message.stickerId);\n        }\n        if (message.wear !== 0) {\n            writer.uint32(29).float(message.wear);\n        }\n        if (message.scale !== 0) {\n            writer.uint32(37).float(message.scale);\n        }\n        if (message.rotation !== 0) {\n            writer.uint32(45).float(message.rotation);\n        }\n        if (message.tintId !== 0) {\n            writer.uint32(48).uint32(message.tintId);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCEconItemPreviewDataBlock_Sticker();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.slot = reader.uint32();\n                    break;\n                case 2:\n                    message.stickerId = reader.uint32();\n                    break;\n                case 3:\n                    message.wear = reader.float();\n                    break;\n                case 4:\n                    message.scale = reader.float();\n                    break;\n                case 5:\n                    message.rotation = reader.float();\n                    break;\n                case 6:\n                    message.tintId = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f;\n        const message = createBaseCEconItemPreviewDataBlock_Sticker();\n        message.slot = (_a = object.slot) !== null && _a !== void 0 ? _a : 0;\n        message.stickerId = (_b = object.stickerId) !== null && _b !== void 0 ? _b : 0;\n        message.wear = (_c = object.wear) !== null && _c !== void 0 ? _c : 0;\n        message.scale = (_d = object.scale) !== null && _d !== void 0 ? _d : 0;\n        message.rotation = (_e = object.rotation) !== null && _e !== void 0 ? _e : 0;\n        message.tintId = (_f = object.tintId) !== null && _f !== void 0 ? _f : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchEndRewardDropsNotification() {\n    return { iteminfo: undefined };\n}\nexports.CMsgGCCStrike15V2MatchEndRewardDropsNotification = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.iteminfo !== undefined) {\n            exports.CEconItemPreviewDataBlock.encode(message.iteminfo, writer.uint32(50).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchEndRewardDropsNotification();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 6:\n                    message.iteminfo = exports.CEconItemPreviewDataBlock.decode(reader, reader.uint32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        const message = createBaseCMsgGCCStrike15V2MatchEndRewardDropsNotification();\n        message.iteminfo =\n            object.iteminfo !== undefined && object.iteminfo !== null\n                ? exports.CEconItemPreviewDataBlock.fromPartial(object.iteminfo)\n                : undefined;\n        return message;\n    }\n};\nfunction createBaseCMsgItemAcknowledged() {\n    return { iteminfo: undefined };\n}\nexports.CMsgItemAcknowledged = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.iteminfo !== undefined) {\n            exports.CEconItemPreviewDataBlock.encode(message.iteminfo, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgItemAcknowledged();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.iteminfo = exports.CEconItemPreviewDataBlock.decode(reader, reader.uint32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        const message = createBaseCMsgItemAcknowledged();\n        message.iteminfo =\n            object.iteminfo !== undefined && object.iteminfo !== null\n                ? exports.CEconItemPreviewDataBlock.fromPartial(object.iteminfo)\n                : undefined;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2Client2GCEconPreviewDataBlockRequest() {\n    return {\n        paramS: Long.UZERO,\n        paramA: Long.UZERO,\n        paramD: Long.UZERO,\n        paramM: Long.UZERO\n    };\n}\nexports.CMsgGCCStrike15V2Client2GCEconPreviewDataBlockRequest = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.paramS.isZero()) {\n            writer.uint32(8).uint64(message.paramS);\n        }\n        if (!message.paramA.isZero()) {\n            writer.uint32(16).uint64(message.paramA);\n        }\n        if (!message.paramD.isZero()) {\n            writer.uint32(24).uint64(message.paramD);\n        }\n        if (!message.paramM.isZero()) {\n            writer.uint32(32).uint64(message.paramM);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2Client2GCEconPreviewDataBlockRequest();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.paramS = reader.uint64();\n                    break;\n                case 2:\n                    message.paramA = reader.uint64();\n                    break;\n                case 3:\n                    message.paramD = reader.uint64();\n                    break;\n                case 4:\n                    message.paramM = reader.uint64();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        const message = createBaseCMsgGCCStrike15V2Client2GCEconPreviewDataBlockRequest();\n        message.paramS =\n            object.paramS !== undefined && object.paramS !== null\n                ? Long.fromValue(object.paramS)\n                : Long.UZERO;\n        message.paramA =\n            object.paramA !== undefined && object.paramA !== null\n                ? Long.fromValue(object.paramA)\n                : Long.UZERO;\n        message.paramD =\n            object.paramD !== undefined && object.paramD !== null\n                ? Long.fromValue(object.paramD)\n                : Long.UZERO;\n        message.paramM =\n            object.paramM !== undefined && object.paramM !== null\n                ? Long.fromValue(object.paramM)\n                : Long.UZERO;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2Client2GCEconPreviewDataBlockResponse() {\n    return { iteminfo: undefined };\n}\nexports.CMsgGCCStrike15V2Client2GCEconPreviewDataBlockResponse = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.iteminfo !== undefined) {\n            exports.CEconItemPreviewDataBlock.encode(message.iteminfo, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2Client2GCEconPreviewDataBlockResponse();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.iteminfo = exports.CEconItemPreviewDataBlock.decode(reader, reader.uint32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        const message = createBaseCMsgGCCStrike15V2Client2GCEconPreviewDataBlockResponse();\n        message.iteminfo =\n            object.iteminfo !== undefined && object.iteminfo !== null\n                ? exports.CEconItemPreviewDataBlock.fromPartial(object.iteminfo)\n                : undefined;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchListRequestCurrentLiveGames() {\n    return {};\n}\nexports.CMsgGCCStrike15V2MatchListRequestCurrentLiveGames = {\n    encode(_, writer = minimal_1.Writer.create()) {\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchListRequestCurrentLiveGames();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(_) {\n        const message = createBaseCMsgGCCStrike15V2MatchListRequestCurrentLiveGames();\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchListRequestLiveGameForUser() {\n    return { accountid: 0 };\n}\nexports.CMsgGCCStrike15V2MatchListRequestLiveGameForUser = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountid !== 0) {\n            writer.uint32(8).uint32(message.accountid);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchListRequestLiveGameForUser();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountid = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2MatchListRequestLiveGameForUser();\n        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchListRequestRecentUserGames() {\n    return { accountid: 0 };\n}\nexports.CMsgGCCStrike15V2MatchListRequestRecentUserGames = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountid !== 0) {\n            writer.uint32(8).uint32(message.accountid);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchListRequestRecentUserGames();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountid = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2MatchListRequestRecentUserGames();\n        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchListRequestTournamentGames() {\n    return { eventid: 0 };\n}\nexports.CMsgGCCStrike15V2MatchListRequestTournamentGames = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.eventid !== 0) {\n            writer.uint32(8).int32(message.eventid);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchListRequestTournamentGames();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.eventid = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2MatchListRequestTournamentGames();\n        message.eventid = (_a = object.eventid) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchListRequestFullGameInfo() {\n    return { matchid: Long.UZERO, outcomeid: Long.UZERO, token: 0 };\n}\nexports.CMsgGCCStrike15V2MatchListRequestFullGameInfo = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.matchid.isZero()) {\n            writer.uint32(8).uint64(message.matchid);\n        }\n        if (!message.outcomeid.isZero()) {\n            writer.uint32(16).uint64(message.outcomeid);\n        }\n        if (message.token !== 0) {\n            writer.uint32(24).uint32(message.token);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchListRequestFullGameInfo();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.matchid = reader.uint64();\n                    break;\n                case 2:\n                    message.outcomeid = reader.uint64();\n                    break;\n                case 3:\n                    message.token = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2MatchListRequestFullGameInfo();\n        message.matchid =\n            object.matchid !== undefined && object.matchid !== null\n                ? Long.fromValue(object.matchid)\n                : Long.UZERO;\n        message.outcomeid =\n            object.outcomeid !== undefined && object.outcomeid !== null\n                ? Long.fromValue(object.outcomeid)\n                : Long.UZERO;\n        message.token = (_a = object.token) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCDataGCCStrike15V2MatchInfo() {\n    return {\n        matchid: Long.UZERO,\n        matchtime: 0,\n        watchablematchinfo: undefined,\n        roundstatsLegacy: undefined,\n        roundstatsall: []\n    };\n}\nexports.CDataGCCStrike15V2MatchInfo = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.matchid.isZero()) {\n            writer.uint32(8).uint64(message.matchid);\n        }\n        if (message.matchtime !== 0) {\n            writer.uint32(16).uint32(message.matchtime);\n        }\n        if (message.watchablematchinfo !== undefined) {\n            exports.WatchableMatchInfo.encode(message.watchablematchinfo, writer.uint32(26).fork()).ldelim();\n        }\n        if (message.roundstatsLegacy !== undefined) {\n            exports.CMsgGCCStrike15V2MatchmakingServerRoundStats.encode(message.roundstatsLegacy, writer.uint32(34).fork()).ldelim();\n        }\n        for (const v of message.roundstatsall) {\n            exports.CMsgGCCStrike15V2MatchmakingServerRoundStats.encode(v, writer.uint32(42).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCDataGCCStrike15V2MatchInfo();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.matchid = reader.uint64();\n                    break;\n                case 2:\n                    message.matchtime = reader.uint32();\n                    break;\n                case 3:\n                    message.watchablematchinfo = exports.WatchableMatchInfo.decode(reader, reader.uint32());\n                    break;\n                case 4:\n                    message.roundstatsLegacy =\n                        exports.CMsgGCCStrike15V2MatchmakingServerRoundStats.decode(reader, reader.uint32());\n                    break;\n                case 5:\n                    message.roundstatsall.push(exports.CMsgGCCStrike15V2MatchmakingServerRoundStats.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCDataGCCStrike15V2MatchInfo();\n        message.matchid =\n            object.matchid !== undefined && object.matchid !== null\n                ? Long.fromValue(object.matchid)\n                : Long.UZERO;\n        message.matchtime = (_a = object.matchtime) !== null && _a !== void 0 ? _a : 0;\n        message.watchablematchinfo =\n            object.watchablematchinfo !== undefined &&\n                object.watchablematchinfo !== null\n                ? exports.WatchableMatchInfo.fromPartial(object.watchablematchinfo)\n                : undefined;\n        message.roundstatsLegacy =\n            object.roundstatsLegacy !== undefined && object.roundstatsLegacy !== null\n                ? exports.CMsgGCCStrike15V2MatchmakingServerRoundStats.fromPartial(object.roundstatsLegacy)\n                : undefined;\n        message.roundstatsall =\n            ((_b = object.roundstatsall) === null || _b === void 0 ? void 0 : _b.map(e => exports.CMsgGCCStrike15V2MatchmakingServerRoundStats.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCDataGCCStrike15V2TournamentGroupTeam() {\n    return { teamId: 0, score: 0, correctpick: false };\n}\nexports.CDataGCCStrike15V2TournamentGroupTeam = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.teamId !== 0) {\n            writer.uint32(8).int32(message.teamId);\n        }\n        if (message.score !== 0) {\n            writer.uint32(16).int32(message.score);\n        }\n        if (message.correctpick === true) {\n            writer.uint32(24).bool(message.correctpick);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCDataGCCStrike15V2TournamentGroupTeam();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.teamId = reader.int32();\n                    break;\n                case 2:\n                    message.score = reader.int32();\n                    break;\n                case 3:\n                    message.correctpick = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCDataGCCStrike15V2TournamentGroupTeam();\n        message.teamId = (_a = object.teamId) !== null && _a !== void 0 ? _a : 0;\n        message.score = (_b = object.score) !== null && _b !== void 0 ? _b : 0;\n        message.correctpick = (_c = object.correctpick) !== null && _c !== void 0 ? _c : false;\n        return message;\n    }\n};\nfunction createBaseCDataGCCStrike15V2TournamentGroup() {\n    return {\n        groupid: 0,\n        name: \"\",\n        desc: \"\",\n        picksDeprecated: 0,\n        teams: [],\n        stageIds: [],\n        picklockuntiltime: 0,\n        pickableteams: 0,\n        pointsPerPick: 0,\n        picks: []\n    };\n}\nexports.CDataGCCStrike15V2TournamentGroup = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.groupid !== 0) {\n            writer.uint32(8).uint32(message.groupid);\n        }\n        if (message.name !== \"\") {\n            writer.uint32(18).string(message.name);\n        }\n        if (message.desc !== \"\") {\n            writer.uint32(26).string(message.desc);\n        }\n        if (message.picksDeprecated !== 0) {\n            writer.uint32(32).uint32(message.picksDeprecated);\n        }\n        for (const v of message.teams) {\n            exports.CDataGCCStrike15V2TournamentGroupTeam.encode(v, writer.uint32(42).fork()).ldelim();\n        }\n        writer.uint32(50).fork();\n        for (const v of message.stageIds) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        if (message.picklockuntiltime !== 0) {\n            writer.uint32(56).uint32(message.picklockuntiltime);\n        }\n        if (message.pickableteams !== 0) {\n            writer.uint32(64).uint32(message.pickableteams);\n        }\n        if (message.pointsPerPick !== 0) {\n            writer.uint32(72).uint32(message.pointsPerPick);\n        }\n        for (const v of message.picks) {\n            exports.CDataGCCStrike15V2TournamentGroup_Picks.encode(v, writer.uint32(82).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCDataGCCStrike15V2TournamentGroup();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.groupid = reader.uint32();\n                    break;\n                case 2:\n                    message.name = reader.string();\n                    break;\n                case 3:\n                    message.desc = reader.string();\n                    break;\n                case 4:\n                    message.picksDeprecated = reader.uint32();\n                    break;\n                case 5:\n                    message.teams.push(exports.CDataGCCStrike15V2TournamentGroupTeam.decode(reader, reader.uint32()));\n                    break;\n                case 6:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.stageIds.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.stageIds.push(reader.int32());\n                    }\n                    break;\n                case 7:\n                    message.picklockuntiltime = reader.uint32();\n                    break;\n                case 8:\n                    message.pickableteams = reader.uint32();\n                    break;\n                case 9:\n                    message.pointsPerPick = reader.uint32();\n                    break;\n                case 10:\n                    message.picks.push(exports.CDataGCCStrike15V2TournamentGroup_Picks.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;\n        const message = createBaseCDataGCCStrike15V2TournamentGroup();\n        message.groupid = (_a = object.groupid) !== null && _a !== void 0 ? _a : 0;\n        message.name = (_b = object.name) !== null && _b !== void 0 ? _b : \"\";\n        message.desc = (_c = object.desc) !== null && _c !== void 0 ? _c : \"\";\n        message.picksDeprecated = (_d = object.picksDeprecated) !== null && _d !== void 0 ? _d : 0;\n        message.teams =\n            ((_e = object.teams) === null || _e === void 0 ? void 0 : _e.map(e => exports.CDataGCCStrike15V2TournamentGroupTeam.fromPartial(e))) || [];\n        message.stageIds = ((_f = object.stageIds) === null || _f === void 0 ? void 0 : _f.map(e => e)) || [];\n        message.picklockuntiltime = (_g = object.picklockuntiltime) !== null && _g !== void 0 ? _g : 0;\n        message.pickableteams = (_h = object.pickableteams) !== null && _h !== void 0 ? _h : 0;\n        message.pointsPerPick = (_j = object.pointsPerPick) !== null && _j !== void 0 ? _j : 0;\n        message.picks =\n            ((_k = object.picks) === null || _k === void 0 ? void 0 : _k.map(e => exports.CDataGCCStrike15V2TournamentGroup_Picks.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCDataGCCStrike15V2TournamentGroup_Picks() {\n    return { pickids: [] };\n}\nexports.CDataGCCStrike15V2TournamentGroup_Picks = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        writer.uint32(10).fork();\n        for (const v of message.pickids) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCDataGCCStrike15V2TournamentGroup_Picks();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.pickids.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.pickids.push(reader.int32());\n                    }\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCDataGCCStrike15V2TournamentGroup_Picks();\n        message.pickids = ((_a = object.pickids) === null || _a === void 0 ? void 0 : _a.map(e => e)) || [];\n        return message;\n    }\n};\nfunction createBaseCDataGCCStrike15V2TournamentSection() {\n    return { sectionid: 0, name: \"\", desc: \"\", groups: [] };\n}\nexports.CDataGCCStrike15V2TournamentSection = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.sectionid !== 0) {\n            writer.uint32(8).uint32(message.sectionid);\n        }\n        if (message.name !== \"\") {\n            writer.uint32(18).string(message.name);\n        }\n        if (message.desc !== \"\") {\n            writer.uint32(26).string(message.desc);\n        }\n        for (const v of message.groups) {\n            exports.CDataGCCStrike15V2TournamentGroup.encode(v, writer.uint32(34).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCDataGCCStrike15V2TournamentSection();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.sectionid = reader.uint32();\n                    break;\n                case 2:\n                    message.name = reader.string();\n                    break;\n                case 3:\n                    message.desc = reader.string();\n                    break;\n                case 4:\n                    message.groups.push(exports.CDataGCCStrike15V2TournamentGroup.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCDataGCCStrike15V2TournamentSection();\n        message.sectionid = (_a = object.sectionid) !== null && _a !== void 0 ? _a : 0;\n        message.name = (_b = object.name) !== null && _b !== void 0 ? _b : \"\";\n        message.desc = (_c = object.desc) !== null && _c !== void 0 ? _c : \"\";\n        message.groups =\n            ((_d = object.groups) === null || _d === void 0 ? void 0 : _d.map(e => exports.CDataGCCStrike15V2TournamentGroup.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCDataGCCStrike15V2TournamentInfo() {\n    return { sections: [], tournamentEvent: undefined, tournamentTeams: [] };\n}\nexports.CDataGCCStrike15V2TournamentInfo = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.sections) {\n            exports.CDataGCCStrike15V2TournamentSection.encode(v, writer.uint32(10).fork()).ldelim();\n        }\n        if (message.tournamentEvent !== undefined) {\n            exports.TournamentEvent.encode(message.tournamentEvent, writer.uint32(18).fork()).ldelim();\n        }\n        for (const v of message.tournamentTeams) {\n            exports.TournamentTeam.encode(v, writer.uint32(26).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCDataGCCStrike15V2TournamentInfo();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.sections.push(exports.CDataGCCStrike15V2TournamentSection.decode(reader, reader.uint32()));\n                    break;\n                case 2:\n                    message.tournamentEvent = exports.TournamentEvent.decode(reader, reader.uint32());\n                    break;\n                case 3:\n                    message.tournamentTeams.push(exports.TournamentTeam.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCDataGCCStrike15V2TournamentInfo();\n        message.sections =\n            ((_a = object.sections) === null || _a === void 0 ? void 0 : _a.map(e => exports.CDataGCCStrike15V2TournamentSection.fromPartial(e))) || [];\n        message.tournamentEvent =\n            object.tournamentEvent !== undefined && object.tournamentEvent !== null\n                ? exports.TournamentEvent.fromPartial(object.tournamentEvent)\n                : undefined;\n        message.tournamentTeams =\n            ((_b = object.tournamentTeams) === null || _b === void 0 ? void 0 : _b.map(e => exports.TournamentTeam.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchList() {\n    return {\n        msgrequestid: 0,\n        accountid: 0,\n        servertime: 0,\n        matches: [],\n        streams: [],\n        tournamentinfo: undefined\n    };\n}\nexports.CMsgGCCStrike15V2MatchList = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.msgrequestid !== 0) {\n            writer.uint32(8).uint32(message.msgrequestid);\n        }\n        if (message.accountid !== 0) {\n            writer.uint32(16).uint32(message.accountid);\n        }\n        if (message.servertime !== 0) {\n            writer.uint32(24).uint32(message.servertime);\n        }\n        for (const v of message.matches) {\n            exports.CDataGCCStrike15V2MatchInfo.encode(v, writer.uint32(34).fork()).ldelim();\n        }\n        for (const v of message.streams) {\n            exports.TournamentTeam.encode(v, writer.uint32(42).fork()).ldelim();\n        }\n        if (message.tournamentinfo !== undefined) {\n            exports.CDataGCCStrike15V2TournamentInfo.encode(message.tournamentinfo, writer.uint32(50).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchList();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.msgrequestid = reader.uint32();\n                    break;\n                case 2:\n                    message.accountid = reader.uint32();\n                    break;\n                case 3:\n                    message.servertime = reader.uint32();\n                    break;\n                case 4:\n                    message.matches.push(exports.CDataGCCStrike15V2MatchInfo.decode(reader, reader.uint32()));\n                    break;\n                case 5:\n                    message.streams.push(exports.TournamentTeam.decode(reader, reader.uint32()));\n                    break;\n                case 6:\n                    message.tournamentinfo = exports.CDataGCCStrike15V2TournamentInfo.decode(reader, reader.uint32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseCMsgGCCStrike15V2MatchList();\n        message.msgrequestid = (_a = object.msgrequestid) !== null && _a !== void 0 ? _a : 0;\n        message.accountid = (_b = object.accountid) !== null && _b !== void 0 ? _b : 0;\n        message.servertime = (_c = object.servertime) !== null && _c !== void 0 ? _c : 0;\n        message.matches =\n            ((_d = object.matches) === null || _d === void 0 ? void 0 : _d.map(e => exports.CDataGCCStrike15V2MatchInfo.fromPartial(e))) ||\n                [];\n        message.streams =\n            ((_e = object.streams) === null || _e === void 0 ? void 0 : _e.map(e => exports.TournamentTeam.fromPartial(e))) || [];\n        message.tournamentinfo =\n            object.tournamentinfo !== undefined && object.tournamentinfo !== null\n                ? exports.CDataGCCStrike15V2TournamentInfo.fromPartial(object.tournamentinfo)\n                : undefined;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2MatchListTournamentOperatorMgmt() {\n    return { eventid: 0, matches: [] };\n}\nexports.CMsgGCCStrike15V2MatchListTournamentOperatorMgmt = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.eventid !== 0) {\n            writer.uint32(8).int32(message.eventid);\n        }\n        for (const v of message.matches) {\n            exports.CDataGCCStrike15V2MatchInfo.encode(v, writer.uint32(18).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2MatchListTournamentOperatorMgmt();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.eventid = reader.int32();\n                    break;\n                case 2:\n                    message.matches.push(exports.CDataGCCStrike15V2MatchInfo.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2MatchListTournamentOperatorMgmt();\n        message.eventid = (_a = object.eventid) !== null && _a !== void 0 ? _a : 0;\n        message.matches =\n            ((_b = object.matches) === null || _b === void 0 ? void 0 : _b.map(e => exports.CDataGCCStrike15V2MatchInfo.fromPartial(e))) ||\n                [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2Predictions() {\n    return { eventId: 0, groupMatchTeamPicks: [] };\n}\nexports.CMsgGCCStrike15V2Predictions = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.eventId !== 0) {\n            writer.uint32(8).uint32(message.eventId);\n        }\n        for (const v of message.groupMatchTeamPicks) {\n            exports.CMsgGCCStrike15V2Predictions_GroupMatchTeamPick.encode(v, writer.uint32(18).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2Predictions();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.eventId = reader.uint32();\n                    break;\n                case 2:\n                    message.groupMatchTeamPicks.push(exports.CMsgGCCStrike15V2Predictions_GroupMatchTeamPick.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2Predictions();\n        message.eventId = (_a = object.eventId) !== null && _a !== void 0 ? _a : 0;\n        message.groupMatchTeamPicks =\n            ((_b = object.groupMatchTeamPicks) === null || _b === void 0 ? void 0 : _b.map(e => exports.CMsgGCCStrike15V2Predictions_GroupMatchTeamPick.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2Predictions_GroupMatchTeamPick() {\n    return { sectionid: 0, groupid: 0, index: 0, teamid: 0, itemid: Long.UZERO };\n}\nexports.CMsgGCCStrike15V2Predictions_GroupMatchTeamPick = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.sectionid !== 0) {\n            writer.uint32(8).int32(message.sectionid);\n        }\n        if (message.groupid !== 0) {\n            writer.uint32(16).int32(message.groupid);\n        }\n        if (message.index !== 0) {\n            writer.uint32(24).int32(message.index);\n        }\n        if (message.teamid !== 0) {\n            writer.uint32(32).int32(message.teamid);\n        }\n        if (!message.itemid.isZero()) {\n            writer.uint32(40).uint64(message.itemid);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2Predictions_GroupMatchTeamPick();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.sectionid = reader.int32();\n                    break;\n                case 2:\n                    message.groupid = reader.int32();\n                    break;\n                case 3:\n                    message.index = reader.int32();\n                    break;\n                case 4:\n                    message.teamid = reader.int32();\n                    break;\n                case 5:\n                    message.itemid = reader.uint64();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCMsgGCCStrike15V2Predictions_GroupMatchTeamPick();\n        message.sectionid = (_a = object.sectionid) !== null && _a !== void 0 ? _a : 0;\n        message.groupid = (_b = object.groupid) !== null && _b !== void 0 ? _b : 0;\n        message.index = (_c = object.index) !== null && _c !== void 0 ? _c : 0;\n        message.teamid = (_d = object.teamid) !== null && _d !== void 0 ? _d : 0;\n        message.itemid =\n            object.itemid !== undefined && object.itemid !== null\n                ? Long.fromValue(object.itemid)\n                : Long.UZERO;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2Fantasy() {\n    return { eventId: 0, teams: [] };\n}\nexports.CMsgGCCStrike15V2Fantasy = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.eventId !== 0) {\n            writer.uint32(8).uint32(message.eventId);\n        }\n        for (const v of message.teams) {\n            exports.CMsgGCCStrike15V2Fantasy_FantasyTeam.encode(v, writer.uint32(18).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2Fantasy();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.eventId = reader.uint32();\n                    break;\n                case 2:\n                    message.teams.push(exports.CMsgGCCStrike15V2Fantasy_FantasyTeam.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2Fantasy();\n        message.eventId = (_a = object.eventId) !== null && _a !== void 0 ? _a : 0;\n        message.teams =\n            ((_b = object.teams) === null || _b === void 0 ? void 0 : _b.map(e => exports.CMsgGCCStrike15V2Fantasy_FantasyTeam.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2Fantasy_FantasySlot() {\n    return { type: 0, pick: 0, itemid: Long.UZERO };\n}\nexports.CMsgGCCStrike15V2Fantasy_FantasySlot = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.type !== 0) {\n            writer.uint32(8).int32(message.type);\n        }\n        if (message.pick !== 0) {\n            writer.uint32(16).int32(message.pick);\n        }\n        if (!message.itemid.isZero()) {\n            writer.uint32(24).uint64(message.itemid);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2Fantasy_FantasySlot();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.type = reader.int32();\n                    break;\n                case 2:\n                    message.pick = reader.int32();\n                    break;\n                case 3:\n                    message.itemid = reader.uint64();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2Fantasy_FantasySlot();\n        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;\n        message.pick = (_b = object.pick) !== null && _b !== void 0 ? _b : 0;\n        message.itemid =\n            object.itemid !== undefined && object.itemid !== null\n                ? Long.fromValue(object.itemid)\n                : Long.UZERO;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2Fantasy_FantasyTeam() {\n    return { sectionid: 0, slots: [] };\n}\nexports.CMsgGCCStrike15V2Fantasy_FantasyTeam = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.sectionid !== 0) {\n            writer.uint32(8).int32(message.sectionid);\n        }\n        for (const v of message.slots) {\n            exports.CMsgGCCStrike15V2Fantasy_FantasySlot.encode(v, writer.uint32(18).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2Fantasy_FantasyTeam();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.sectionid = reader.int32();\n                    break;\n                case 2:\n                    message.slots.push(exports.CMsgGCCStrike15V2Fantasy_FantasySlot.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2Fantasy_FantasyTeam();\n        message.sectionid = (_a = object.sectionid) !== null && _a !== void 0 ? _a : 0;\n        message.slots =\n            ((_b = object.slots) === null || _b === void 0 ? void 0 : _b.map(e => exports.CMsgGCCStrike15V2Fantasy_FantasySlot.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCAttributeString() {\n    return { value: \"\" };\n}\nexports.CAttributeString = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.value !== \"\") {\n            writer.uint32(10).string(message.value);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCAttributeString();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.value = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCAttributeString();\n        message.value = (_a = object.value) !== null && _a !== void 0 ? _a : \"\";\n        return message;\n    }\n};\nfunction createBaseCMsgCStrike15Welcome() {\n    return {\n        storeItemHash: 0,\n        timeplayedconsecutively: 0,\n        timeFirstPlayed: 0,\n        lastTimePlayed: 0,\n        lastIpAddress: 0,\n        gscookieid: Long.UZERO,\n        uniqueid: Long.UZERO\n    };\n}\nexports.CMsgCStrike15Welcome = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.storeItemHash !== 0) {\n            writer.uint32(40).uint32(message.storeItemHash);\n        }\n        if (message.timeplayedconsecutively !== 0) {\n            writer.uint32(48).uint32(message.timeplayedconsecutively);\n        }\n        if (message.timeFirstPlayed !== 0) {\n            writer.uint32(80).uint32(message.timeFirstPlayed);\n        }\n        if (message.lastTimePlayed !== 0) {\n            writer.uint32(96).uint32(message.lastTimePlayed);\n        }\n        if (message.lastIpAddress !== 0) {\n            writer.uint32(104).uint32(message.lastIpAddress);\n        }\n        if (!message.gscookieid.isZero()) {\n            writer.uint32(144).uint64(message.gscookieid);\n        }\n        if (!message.uniqueid.isZero()) {\n            writer.uint32(152).uint64(message.uniqueid);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgCStrike15Welcome();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 5:\n                    message.storeItemHash = reader.uint32();\n                    break;\n                case 6:\n                    message.timeplayedconsecutively = reader.uint32();\n                    break;\n                case 10:\n                    message.timeFirstPlayed = reader.uint32();\n                    break;\n                case 12:\n                    message.lastTimePlayed = reader.uint32();\n                    break;\n                case 13:\n                    message.lastIpAddress = reader.uint32();\n                    break;\n                case 18:\n                    message.gscookieid = reader.uint64();\n                    break;\n                case 19:\n                    message.uniqueid = reader.uint64();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseCMsgCStrike15Welcome();\n        message.storeItemHash = (_a = object.storeItemHash) !== null && _a !== void 0 ? _a : 0;\n        message.timeplayedconsecutively = (_b = object.timeplayedconsecutively) !== null && _b !== void 0 ? _b : 0;\n        message.timeFirstPlayed = (_c = object.timeFirstPlayed) !== null && _c !== void 0 ? _c : 0;\n        message.lastTimePlayed = (_d = object.lastTimePlayed) !== null && _d !== void 0 ? _d : 0;\n        message.lastIpAddress = (_e = object.lastIpAddress) !== null && _e !== void 0 ? _e : 0;\n        message.gscookieid =\n            object.gscookieid !== undefined && object.gscookieid !== null\n                ? Long.fromValue(object.gscookieid)\n                : Long.UZERO;\n        message.uniqueid =\n            object.uniqueid !== undefined && object.uniqueid !== null\n                ? Long.fromValue(object.uniqueid)\n                : Long.UZERO;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientVarValueNotificationInfo() {\n    return {\n        valueName: \"\",\n        valueInt: 0,\n        serverAddr: 0,\n        serverPort: 0,\n        chokedBlocks: []\n    };\n}\nexports.CMsgGCCStrike15V2ClientVarValueNotificationInfo = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.valueName !== \"\") {\n            writer.uint32(10).string(message.valueName);\n        }\n        if (message.valueInt !== 0) {\n            writer.uint32(16).int32(message.valueInt);\n        }\n        if (message.serverAddr !== 0) {\n            writer.uint32(24).uint32(message.serverAddr);\n        }\n        if (message.serverPort !== 0) {\n            writer.uint32(32).uint32(message.serverPort);\n        }\n        for (const v of message.chokedBlocks) {\n            writer.uint32(42).string(v);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientVarValueNotificationInfo();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.valueName = reader.string();\n                    break;\n                case 2:\n                    message.valueInt = reader.int32();\n                    break;\n                case 3:\n                    message.serverAddr = reader.uint32();\n                    break;\n                case 4:\n                    message.serverPort = reader.uint32();\n                    break;\n                case 5:\n                    message.chokedBlocks.push(reader.string());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseCMsgGCCStrike15V2ClientVarValueNotificationInfo();\n        message.valueName = (_a = object.valueName) !== null && _a !== void 0 ? _a : \"\";\n        message.valueInt = (_b = object.valueInt) !== null && _b !== void 0 ? _b : 0;\n        message.serverAddr = (_c = object.serverAddr) !== null && _c !== void 0 ? _c : 0;\n        message.serverPort = (_d = object.serverPort) !== null && _d !== void 0 ? _d : 0;\n        message.chokedBlocks = ((_e = object.chokedBlocks) === null || _e === void 0 ? void 0 : _e.map(e => e)) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ServerVarValueNotificationInfo() {\n    return { accountid: 0, viewangles: [], type: 0, userdata: [] };\n}\nexports.CMsgGCCStrike15V2ServerVarValueNotificationInfo = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountid !== 0) {\n            writer.uint32(8).uint32(message.accountid);\n        }\n        writer.uint32(18).fork();\n        for (const v of message.viewangles) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        if (message.type !== 0) {\n            writer.uint32(24).uint32(message.type);\n        }\n        writer.uint32(34).fork();\n        for (const v of message.userdata) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ServerVarValueNotificationInfo();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountid = reader.uint32();\n                    break;\n                case 2:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.viewangles.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.viewangles.push(reader.uint32());\n                    }\n                    break;\n                case 3:\n                    message.type = reader.uint32();\n                    break;\n                case 4:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.userdata.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.userdata.push(reader.uint32());\n                    }\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCMsgGCCStrike15V2ServerVarValueNotificationInfo();\n        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;\n        message.viewangles = ((_b = object.viewangles) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];\n        message.type = (_c = object.type) !== null && _c !== void 0 ? _c : 0;\n        message.userdata = ((_d = object.userdata) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2GiftsLeaderboardRequest() {\n    return {};\n}\nexports.CMsgGCCStrike15V2GiftsLeaderboardRequest = {\n    encode(_, writer = minimal_1.Writer.create()) {\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2GiftsLeaderboardRequest();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(_) {\n        const message = createBaseCMsgGCCStrike15V2GiftsLeaderboardRequest();\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2GiftsLeaderboardResponse() {\n    return {\n        servertime: 0,\n        timePeriodSeconds: 0,\n        totalGiftsGiven: 0,\n        totalGivers: 0,\n        entries: []\n    };\n}\nexports.CMsgGCCStrike15V2GiftsLeaderboardResponse = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.servertime !== 0) {\n            writer.uint32(8).uint32(message.servertime);\n        }\n        if (message.timePeriodSeconds !== 0) {\n            writer.uint32(16).uint32(message.timePeriodSeconds);\n        }\n        if (message.totalGiftsGiven !== 0) {\n            writer.uint32(24).uint32(message.totalGiftsGiven);\n        }\n        if (message.totalGivers !== 0) {\n            writer.uint32(32).uint32(message.totalGivers);\n        }\n        for (const v of message.entries) {\n            exports.CMsgGCCStrike15V2GiftsLeaderboardResponse_GiftLeaderboardEntry.encode(v, writer.uint32(42).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2GiftsLeaderboardResponse();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.servertime = reader.uint32();\n                    break;\n                case 2:\n                    message.timePeriodSeconds = reader.uint32();\n                    break;\n                case 3:\n                    message.totalGiftsGiven = reader.uint32();\n                    break;\n                case 4:\n                    message.totalGivers = reader.uint32();\n                    break;\n                case 5:\n                    message.entries.push(exports.CMsgGCCStrike15V2GiftsLeaderboardResponse_GiftLeaderboardEntry.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseCMsgGCCStrike15V2GiftsLeaderboardResponse();\n        message.servertime = (_a = object.servertime) !== null && _a !== void 0 ? _a : 0;\n        message.timePeriodSeconds = (_b = object.timePeriodSeconds) !== null && _b !== void 0 ? _b : 0;\n        message.totalGiftsGiven = (_c = object.totalGiftsGiven) !== null && _c !== void 0 ? _c : 0;\n        message.totalGivers = (_d = object.totalGivers) !== null && _d !== void 0 ? _d : 0;\n        message.entries =\n            ((_e = object.entries) === null || _e === void 0 ? void 0 : _e.map(e => exports.CMsgGCCStrike15V2GiftsLeaderboardResponse_GiftLeaderboardEntry.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2GiftsLeaderboardResponse_GiftLeaderboardEntry() {\n    return { accountid: 0, gifts: 0 };\n}\nexports.CMsgGCCStrike15V2GiftsLeaderboardResponse_GiftLeaderboardEntry = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountid !== 0) {\n            writer.uint32(8).uint32(message.accountid);\n        }\n        if (message.gifts !== 0) {\n            writer.uint32(16).uint32(message.gifts);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2GiftsLeaderboardResponse_GiftLeaderboardEntry();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountid = reader.uint32();\n                    break;\n                case 2:\n                    message.gifts = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2GiftsLeaderboardResponse_GiftLeaderboardEntry();\n        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;\n        message.gifts = (_b = object.gifts) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientSubmitSurveyVote() {\n    return { surveyId: 0, vote: 0 };\n}\nexports.CMsgGCCStrike15V2ClientSubmitSurveyVote = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.surveyId !== 0) {\n            writer.uint32(8).uint32(message.surveyId);\n        }\n        if (message.vote !== 0) {\n            writer.uint32(16).uint32(message.vote);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientSubmitSurveyVote();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.surveyId = reader.uint32();\n                    break;\n                case 2:\n                    message.vote = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2ClientSubmitSurveyVote();\n        message.surveyId = (_a = object.surveyId) !== null && _a !== void 0 ? _a : 0;\n        message.vote = (_b = object.vote) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2Server2GCClientValidate() {\n    return { accountid: 0 };\n}\nexports.CMsgGCCStrike15V2Server2GCClientValidate = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountid !== 0) {\n            writer.uint32(8).uint32(message.accountid);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2Server2GCClientValidate();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountid = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2Server2GCClientValidate();\n        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2GC2ClientTournamentInfo() {\n    return { eventid: 0, stageid: 0, gameType: 0, teamids: [] };\n}\nexports.CMsgGCCStrike15V2GC2ClientTournamentInfo = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.eventid !== 0) {\n            writer.uint32(8).uint32(message.eventid);\n        }\n        if (message.stageid !== 0) {\n            writer.uint32(16).uint32(message.stageid);\n        }\n        if (message.gameType !== 0) {\n            writer.uint32(24).uint32(message.gameType);\n        }\n        writer.uint32(34).fork();\n        for (const v of message.teamids) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2GC2ClientTournamentInfo();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.eventid = reader.uint32();\n                    break;\n                case 2:\n                    message.stageid = reader.uint32();\n                    break;\n                case 3:\n                    message.gameType = reader.uint32();\n                    break;\n                case 4:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.teamids.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.teamids.push(reader.uint32());\n                    }\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCMsgGCCStrike15V2GC2ClientTournamentInfo();\n        message.eventid = (_a = object.eventid) !== null && _a !== void 0 ? _a : 0;\n        message.stageid = (_b = object.stageid) !== null && _b !== void 0 ? _b : 0;\n        message.gameType = (_c = object.gameType) !== null && _c !== void 0 ? _c : 0;\n        message.teamids = ((_d = object.teamids) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];\n        return message;\n    }\n};\nfunction createBaseCSOEconCoupon() {\n    return { entryid: 0, defidx: 0, expirationDate: 0 };\n}\nexports.CSOEconCoupon = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.entryid !== 0) {\n            writer.uint32(8).uint32(message.entryid);\n        }\n        if (message.defidx !== 0) {\n            writer.uint32(16).uint32(message.defidx);\n        }\n        if (message.expirationDate !== 0) {\n            writer.uint32(29).fixed32(message.expirationDate);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSOEconCoupon();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.entryid = reader.uint32();\n                    break;\n                case 2:\n                    message.defidx = reader.uint32();\n                    break;\n                case 3:\n                    message.expirationDate = reader.fixed32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCSOEconCoupon();\n        message.entryid = (_a = object.entryid) !== null && _a !== void 0 ? _a : 0;\n        message.defidx = (_b = object.defidx) !== null && _b !== void 0 ? _b : 0;\n        message.expirationDate = (_c = object.expirationDate) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseCSOQuestProgress() {\n    return { questid: 0, pointsRemaining: 0, bonusPoints: 0 };\n}\nexports.CSOQuestProgress = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.questid !== 0) {\n            writer.uint32(8).uint32(message.questid);\n        }\n        if (message.pointsRemaining !== 0) {\n            writer.uint32(16).uint32(message.pointsRemaining);\n        }\n        if (message.bonusPoints !== 0) {\n            writer.uint32(24).uint32(message.bonusPoints);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSOQuestProgress();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.questid = reader.uint32();\n                    break;\n                case 2:\n                    message.pointsRemaining = reader.uint32();\n                    break;\n                case 3:\n                    message.bonusPoints = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCSOQuestProgress();\n        message.questid = (_a = object.questid) !== null && _a !== void 0 ? _a : 0;\n        message.pointsRemaining = (_b = object.pointsRemaining) !== null && _b !== void 0 ? _b : 0;\n        message.bonusPoints = (_c = object.bonusPoints) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseCSOAccountSeasonalOperation() {\n    return {\n        seasonValue: 0,\n        tierUnlocked: 0,\n        premiumTiers: 0,\n        missionId: 0,\n        missionsCompleted: 0,\n        redeemableBalance: 0,\n        seasonPassTime: 0\n    };\n}\nexports.CSOAccountSeasonalOperation = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.seasonValue !== 0) {\n            writer.uint32(8).uint32(message.seasonValue);\n        }\n        if (message.tierUnlocked !== 0) {\n            writer.uint32(16).uint32(message.tierUnlocked);\n        }\n        if (message.premiumTiers !== 0) {\n            writer.uint32(24).uint32(message.premiumTiers);\n        }\n        if (message.missionId !== 0) {\n            writer.uint32(32).uint32(message.missionId);\n        }\n        if (message.missionsCompleted !== 0) {\n            writer.uint32(40).uint32(message.missionsCompleted);\n        }\n        if (message.redeemableBalance !== 0) {\n            writer.uint32(48).uint32(message.redeemableBalance);\n        }\n        if (message.seasonPassTime !== 0) {\n            writer.uint32(56).uint32(message.seasonPassTime);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSOAccountSeasonalOperation();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.seasonValue = reader.uint32();\n                    break;\n                case 2:\n                    message.tierUnlocked = reader.uint32();\n                    break;\n                case 3:\n                    message.premiumTiers = reader.uint32();\n                    break;\n                case 4:\n                    message.missionId = reader.uint32();\n                    break;\n                case 5:\n                    message.missionsCompleted = reader.uint32();\n                    break;\n                case 6:\n                    message.redeemableBalance = reader.uint32();\n                    break;\n                case 7:\n                    message.seasonPassTime = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g;\n        const message = createBaseCSOAccountSeasonalOperation();\n        message.seasonValue = (_a = object.seasonValue) !== null && _a !== void 0 ? _a : 0;\n        message.tierUnlocked = (_b = object.tierUnlocked) !== null && _b !== void 0 ? _b : 0;\n        message.premiumTiers = (_c = object.premiumTiers) !== null && _c !== void 0 ? _c : 0;\n        message.missionId = (_d = object.missionId) !== null && _d !== void 0 ? _d : 0;\n        message.missionsCompleted = (_e = object.missionsCompleted) !== null && _e !== void 0 ? _e : 0;\n        message.redeemableBalance = (_f = object.redeemableBalance) !== null && _f !== void 0 ? _f : 0;\n        message.seasonPassTime = (_g = object.seasonPassTime) !== null && _g !== void 0 ? _g : 0;\n        return message;\n    }\n};\nfunction createBaseCSOAccountRecurringSubscription() {\n    return { timeNextCycle: 0, timeInitiated: 0 };\n}\nexports.CSOAccountRecurringSubscription = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.timeNextCycle !== 0) {\n            writer.uint32(8).uint32(message.timeNextCycle);\n        }\n        if (message.timeInitiated !== 0) {\n            writer.uint32(16).uint32(message.timeInitiated);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSOAccountRecurringSubscription();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.timeNextCycle = reader.uint32();\n                    break;\n                case 2:\n                    message.timeInitiated = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCSOAccountRecurringSubscription();\n        message.timeNextCycle = (_a = object.timeNextCycle) !== null && _a !== void 0 ? _a : 0;\n        message.timeInitiated = (_b = object.timeInitiated) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCSOPersonaDataPublic() {\n    return { playerLevel: 0, commendation: undefined, elevatedState: false };\n}\nexports.CSOPersonaDataPublic = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.playerLevel !== 0) {\n            writer.uint32(8).int32(message.playerLevel);\n        }\n        if (message.commendation !== undefined) {\n            exports.PlayerCommendationInfo.encode(message.commendation, writer.uint32(18).fork()).ldelim();\n        }\n        if (message.elevatedState === true) {\n            writer.uint32(24).bool(message.elevatedState);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSOPersonaDataPublic();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.playerLevel = reader.int32();\n                    break;\n                case 2:\n                    message.commendation = exports.PlayerCommendationInfo.decode(reader, reader.uint32());\n                    break;\n                case 3:\n                    message.elevatedState = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCSOPersonaDataPublic();\n        message.playerLevel = (_a = object.playerLevel) !== null && _a !== void 0 ? _a : 0;\n        message.commendation =\n            object.commendation !== undefined && object.commendation !== null\n                ? exports.PlayerCommendationInfo.fromPartial(object.commendation)\n                : undefined;\n        message.elevatedState = (_b = object.elevatedState) !== null && _b !== void 0 ? _b : false;\n        return message;\n    }\n};\nfunction createBaseCMsgGCGlobalGameSubscribe() {\n    return { ticket: Long.UZERO };\n}\nexports.CMsgGCGlobalGameSubscribe = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.ticket.isZero()) {\n            writer.uint32(8).uint64(message.ticket);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCGlobalGameSubscribe();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.ticket = reader.uint64();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        const message = createBaseCMsgGCGlobalGameSubscribe();\n        message.ticket =\n            object.ticket !== undefined && object.ticket !== null\n                ? Long.fromValue(object.ticket)\n                : Long.UZERO;\n        return message;\n    }\n};\nfunction createBaseCMsgGCGlobalGameUnsubscribe() {\n    return { timeleft: 0 };\n}\nexports.CMsgGCGlobalGameUnsubscribe = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.timeleft !== 0) {\n            writer.uint32(8).int32(message.timeleft);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCGlobalGameUnsubscribe();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.timeleft = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCGlobalGameUnsubscribe();\n        message.timeleft = (_a = object.timeleft) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCGlobalGamePlay() {\n    return { ticket: Long.UZERO, gametimems: 0, msperpoint: 0 };\n}\nexports.CMsgGCGlobalGamePlay = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.ticket.isZero()) {\n            writer.uint32(8).uint64(message.ticket);\n        }\n        if (message.gametimems !== 0) {\n            writer.uint32(16).uint32(message.gametimems);\n        }\n        if (message.msperpoint !== 0) {\n            writer.uint32(24).uint32(message.msperpoint);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCGlobalGamePlay();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.ticket = reader.uint64();\n                    break;\n                case 2:\n                    message.gametimems = reader.uint32();\n                    break;\n                case 3:\n                    message.msperpoint = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCGlobalGamePlay();\n        message.ticket =\n            object.ticket !== undefined && object.ticket !== null\n                ? Long.fromValue(object.ticket)\n                : Long.UZERO;\n        message.gametimems = (_a = object.gametimems) !== null && _a !== void 0 ? _a : 0;\n        message.msperpoint = (_b = object.msperpoint) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2AcknowledgePenalty() {\n    return { acknowledged: 0 };\n}\nexports.CMsgGCCStrike15V2AcknowledgePenalty = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.acknowledged !== 0) {\n            writer.uint32(8).int32(message.acknowledged);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2AcknowledgePenalty();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.acknowledged = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2AcknowledgePenalty();\n        message.acknowledged = (_a = object.acknowledged) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2Client2GCRequestPrestigeCoin() {\n    return { defindex: 0, upgradeid: Long.UZERO, hours: 0, prestigetime: 0 };\n}\nexports.CMsgGCCStrike15V2Client2GCRequestPrestigeCoin = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.defindex !== 0) {\n            writer.uint32(8).uint32(message.defindex);\n        }\n        if (!message.upgradeid.isZero()) {\n            writer.uint32(16).uint64(message.upgradeid);\n        }\n        if (message.hours !== 0) {\n            writer.uint32(24).uint32(message.hours);\n        }\n        if (message.prestigetime !== 0) {\n            writer.uint32(32).uint32(message.prestigetime);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2Client2GCRequestPrestigeCoin();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.defindex = reader.uint32();\n                    break;\n                case 2:\n                    message.upgradeid = reader.uint64();\n                    break;\n                case 3:\n                    message.hours = reader.uint32();\n                    break;\n                case 4:\n                    message.prestigetime = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCMsgGCCStrike15V2Client2GCRequestPrestigeCoin();\n        message.defindex = (_a = object.defindex) !== null && _a !== void 0 ? _a : 0;\n        message.upgradeid =\n            object.upgradeid !== undefined && object.upgradeid !== null\n                ? Long.fromValue(object.upgradeid)\n                : Long.UZERO;\n        message.hours = (_b = object.hours) !== null && _b !== void 0 ? _b : 0;\n        message.prestigetime = (_c = object.prestigetime) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2Client2GCStreamUnlock() {\n    return { ticket: Long.UZERO, os: 0 };\n}\nexports.CMsgGCCStrike15V2Client2GCStreamUnlock = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.ticket.isZero()) {\n            writer.uint32(8).uint64(message.ticket);\n        }\n        if (message.os !== 0) {\n            writer.uint32(16).int32(message.os);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2Client2GCStreamUnlock();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.ticket = reader.uint64();\n                    break;\n                case 2:\n                    message.os = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2Client2GCStreamUnlock();\n        message.ticket =\n            object.ticket !== undefined && object.ticket !== null\n                ? Long.fromValue(object.ticket)\n                : Long.UZERO;\n        message.os = (_a = object.os) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientToGCRequestElevate() {\n    return { stage: 0 };\n}\nexports.CMsgGCCStrike15V2ClientToGCRequestElevate = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.stage !== 0) {\n            writer.uint32(8).uint32(message.stage);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientToGCRequestElevate();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.stage = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2ClientToGCRequestElevate();\n        message.stage = (_a = object.stage) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientToGCChat() {\n    return { matchId: Long.UZERO, text: \"\" };\n}\nexports.CMsgGCCStrike15V2ClientToGCChat = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.matchId.isZero()) {\n            writer.uint32(8).uint64(message.matchId);\n        }\n        if (message.text !== \"\") {\n            writer.uint32(18).string(message.text);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientToGCChat();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.matchId = reader.uint64();\n                    break;\n                case 2:\n                    message.text = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2ClientToGCChat();\n        message.matchId =\n            object.matchId !== undefined && object.matchId !== null\n                ? Long.fromValue(object.matchId)\n                : Long.UZERO;\n        message.text = (_a = object.text) !== null && _a !== void 0 ? _a : \"\";\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2GCToClientChat() {\n    return { accountId: 0, text: \"\" };\n}\nexports.CMsgGCCStrike15V2GCToClientChat = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountId !== 0) {\n            writer.uint32(8).uint32(message.accountId);\n        }\n        if (message.text !== \"\") {\n            writer.uint32(18).string(message.text);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2GCToClientChat();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountId = reader.uint32();\n                    break;\n                case 2:\n                    message.text = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2GCToClientChat();\n        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;\n        message.text = (_b = object.text) !== null && _b !== void 0 ? _b : \"\";\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientAuthKeyCode() {\n    return { eventid: 0, code: \"\" };\n}\nexports.CMsgGCCStrike15V2ClientAuthKeyCode = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.eventid !== 0) {\n            writer.uint32(8).uint32(message.eventid);\n        }\n        if (message.code !== \"\") {\n            writer.uint32(18).string(message.code);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientAuthKeyCode();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.eventid = reader.uint32();\n                    break;\n                case 2:\n                    message.code = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2ClientAuthKeyCode();\n        message.eventid = (_a = object.eventid) !== null && _a !== void 0 ? _a : 0;\n        message.code = (_b = object.code) !== null && _b !== void 0 ? _b : \"\";\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15GotvSyncPacket() {\n    return { data: undefined };\n}\nexports.CMsgGCCStrike15GotvSyncPacket = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.data !== undefined) {\n            engine_gcmessages_1.CEngineGotvSyncPacket.encode(message.data, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15GotvSyncPacket();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.data = engine_gcmessages_1.CEngineGotvSyncPacket.decode(reader, reader.uint32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        const message = createBaseCMsgGCCStrike15GotvSyncPacket();\n        message.data =\n            object.data !== undefined && object.data !== null\n                ? engine_gcmessages_1.CEngineGotvSyncPacket.fromPartial(object.data)\n                : undefined;\n        return message;\n    }\n};\nfunction createBasePlayerDecalDigitalSignature() {\n    return {\n        signature: new Uint8Array(),\n        accountid: 0,\n        rtime: 0,\n        endpos: [],\n        startpos: [],\n        right: [],\n        txDefidx: 0,\n        entindex: 0,\n        hitbox: 0,\n        creationtime: 0,\n        equipslot: 0,\n        traceId: 0,\n        normal: [],\n        tintId: 0\n    };\n}\nexports.PlayerDecalDigitalSignature = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.signature.length !== 0) {\n            writer.uint32(10).bytes(message.signature);\n        }\n        if (message.accountid !== 0) {\n            writer.uint32(16).uint32(message.accountid);\n        }\n        if (message.rtime !== 0) {\n            writer.uint32(24).uint32(message.rtime);\n        }\n        writer.uint32(34).fork();\n        for (const v of message.endpos) {\n            writer.float(v);\n        }\n        writer.ldelim();\n        writer.uint32(42).fork();\n        for (const v of message.startpos) {\n            writer.float(v);\n        }\n        writer.ldelim();\n        writer.uint32(50).fork();\n        for (const v of message.right) {\n            writer.float(v);\n        }\n        writer.ldelim();\n        if (message.txDefidx !== 0) {\n            writer.uint32(56).uint32(message.txDefidx);\n        }\n        if (message.entindex !== 0) {\n            writer.uint32(64).int32(message.entindex);\n        }\n        if (message.hitbox !== 0) {\n            writer.uint32(72).uint32(message.hitbox);\n        }\n        if (message.creationtime !== 0) {\n            writer.uint32(85).float(message.creationtime);\n        }\n        if (message.equipslot !== 0) {\n            writer.uint32(88).uint32(message.equipslot);\n        }\n        if (message.traceId !== 0) {\n            writer.uint32(96).uint32(message.traceId);\n        }\n        writer.uint32(106).fork();\n        for (const v of message.normal) {\n            writer.float(v);\n        }\n        writer.ldelim();\n        if (message.tintId !== 0) {\n            writer.uint32(112).uint32(message.tintId);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBasePlayerDecalDigitalSignature();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.signature = reader.bytes();\n                    break;\n                case 2:\n                    message.accountid = reader.uint32();\n                    break;\n                case 3:\n                    message.rtime = reader.uint32();\n                    break;\n                case 4:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.endpos.push(reader.float());\n                        }\n                    }\n                    else {\n                        message.endpos.push(reader.float());\n                    }\n                    break;\n                case 5:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.startpos.push(reader.float());\n                        }\n                    }\n                    else {\n                        message.startpos.push(reader.float());\n                    }\n                    break;\n                case 6:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.right.push(reader.float());\n                        }\n                    }\n                    else {\n                        message.right.push(reader.float());\n                    }\n                    break;\n                case 7:\n                    message.txDefidx = reader.uint32();\n                    break;\n                case 8:\n                    message.entindex = reader.int32();\n                    break;\n                case 9:\n                    message.hitbox = reader.uint32();\n                    break;\n                case 10:\n                    message.creationtime = reader.float();\n                    break;\n                case 11:\n                    message.equipslot = reader.uint32();\n                    break;\n                case 12:\n                    message.traceId = reader.uint32();\n                    break;\n                case 13:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.normal.push(reader.float());\n                        }\n                    }\n                    else {\n                        message.normal.push(reader.float());\n                    }\n                    break;\n                case 14:\n                    message.tintId = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;\n        const message = createBasePlayerDecalDigitalSignature();\n        message.signature = (_a = object.signature) !== null && _a !== void 0 ? _a : new Uint8Array();\n        message.accountid = (_b = object.accountid) !== null && _b !== void 0 ? _b : 0;\n        message.rtime = (_c = object.rtime) !== null && _c !== void 0 ? _c : 0;\n        message.endpos = ((_d = object.endpos) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];\n        message.startpos = ((_e = object.startpos) === null || _e === void 0 ? void 0 : _e.map(e => e)) || [];\n        message.right = ((_f = object.right) === null || _f === void 0 ? void 0 : _f.map(e => e)) || [];\n        message.txDefidx = (_g = object.txDefidx) !== null && _g !== void 0 ? _g : 0;\n        message.entindex = (_h = object.entindex) !== null && _h !== void 0 ? _h : 0;\n        message.hitbox = (_j = object.hitbox) !== null && _j !== void 0 ? _j : 0;\n        message.creationtime = (_k = object.creationtime) !== null && _k !== void 0 ? _k : 0;\n        message.equipslot = (_l = object.equipslot) !== null && _l !== void 0 ? _l : 0;\n        message.traceId = (_m = object.traceId) !== null && _m !== void 0 ? _m : 0;\n        message.normal = ((_o = object.normal) === null || _o === void 0 ? void 0 : _o.map(e => e)) || [];\n        message.tintId = (_p = object.tintId) !== null && _p !== void 0 ? _p : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientPlayerDecalSign() {\n    return { data: undefined, itemid: Long.UZERO };\n}\nexports.CMsgGCCStrike15V2ClientPlayerDecalSign = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.data !== undefined) {\n            exports.PlayerDecalDigitalSignature.encode(message.data, writer.uint32(10).fork()).ldelim();\n        }\n        if (!message.itemid.isZero()) {\n            writer.uint32(16).uint64(message.itemid);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientPlayerDecalSign();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.data = exports.PlayerDecalDigitalSignature.decode(reader, reader.uint32());\n                    break;\n                case 2:\n                    message.itemid = reader.uint64();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        const message = createBaseCMsgGCCStrike15V2ClientPlayerDecalSign();\n        message.data =\n            object.data !== undefined && object.data !== null\n                ? exports.PlayerDecalDigitalSignature.fromPartial(object.data)\n                : undefined;\n        message.itemid =\n            object.itemid !== undefined && object.itemid !== null\n                ? Long.fromValue(object.itemid)\n                : Long.UZERO;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientLogonFatalError() {\n    return { errorcode: 0, message: \"\", country: \"\" };\n}\nexports.CMsgGCCStrike15V2ClientLogonFatalError = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.errorcode !== 0) {\n            writer.uint32(8).uint32(message.errorcode);\n        }\n        if (message.message !== \"\") {\n            writer.uint32(18).string(message.message);\n        }\n        if (message.country !== \"\") {\n            writer.uint32(26).string(message.country);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientLogonFatalError();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.errorcode = reader.uint32();\n                    break;\n                case 2:\n                    message.message = reader.string();\n                    break;\n                case 3:\n                    message.country = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCMsgGCCStrike15V2ClientLogonFatalError();\n        message.errorcode = (_a = object.errorcode) !== null && _a !== void 0 ? _a : 0;\n        message.message = (_b = object.message) !== null && _b !== void 0 ? _b : \"\";\n        message.country = (_c = object.country) !== null && _c !== void 0 ? _c : \"\";\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientPollState() {\n    return { pollid: 0, names: [], values: [] };\n}\nexports.CMsgGCCStrike15V2ClientPollState = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.pollid !== 0) {\n            writer.uint32(8).uint32(message.pollid);\n        }\n        for (const v of message.names) {\n            writer.uint32(18).string(v);\n        }\n        writer.uint32(26).fork();\n        for (const v of message.values) {\n            writer.int32(v);\n        }\n        writer.ldelim();\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientPollState();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.pollid = reader.uint32();\n                    break;\n                case 2:\n                    message.names.push(reader.string());\n                    break;\n                case 3:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.values.push(reader.int32());\n                        }\n                    }\n                    else {\n                        message.values.push(reader.int32());\n                    }\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCMsgGCCStrike15V2ClientPollState();\n        message.pollid = (_a = object.pollid) !== null && _a !== void 0 ? _a : 0;\n        message.names = ((_b = object.names) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];\n        message.values = ((_c = object.values) === null || _c === void 0 ? void 0 : _c.map(e => e)) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2PartyRegister() {\n    return {\n        id: 0,\n        ver: 0,\n        apr: 0,\n        ark: 0,\n        nby: 0,\n        grp: 0,\n        slots: 0,\n        launcher: 0,\n        gameType: 0\n    };\n}\nexports.CMsgGCCStrike15V2PartyRegister = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.id !== 0) {\n            writer.uint32(8).uint32(message.id);\n        }\n        if (message.ver !== 0) {\n            writer.uint32(16).uint32(message.ver);\n        }\n        if (message.apr !== 0) {\n            writer.uint32(24).uint32(message.apr);\n        }\n        if (message.ark !== 0) {\n            writer.uint32(32).uint32(message.ark);\n        }\n        if (message.nby !== 0) {\n            writer.uint32(40).uint32(message.nby);\n        }\n        if (message.grp !== 0) {\n            writer.uint32(48).uint32(message.grp);\n        }\n        if (message.slots !== 0) {\n            writer.uint32(56).uint32(message.slots);\n        }\n        if (message.launcher !== 0) {\n            writer.uint32(64).uint32(message.launcher);\n        }\n        if (message.gameType !== 0) {\n            writer.uint32(72).uint32(message.gameType);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2PartyRegister();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.id = reader.uint32();\n                    break;\n                case 2:\n                    message.ver = reader.uint32();\n                    break;\n                case 3:\n                    message.apr = reader.uint32();\n                    break;\n                case 4:\n                    message.ark = reader.uint32();\n                    break;\n                case 5:\n                    message.nby = reader.uint32();\n                    break;\n                case 6:\n                    message.grp = reader.uint32();\n                    break;\n                case 7:\n                    message.slots = reader.uint32();\n                    break;\n                case 8:\n                    message.launcher = reader.uint32();\n                    break;\n                case 9:\n                    message.gameType = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j;\n        const message = createBaseCMsgGCCStrike15V2PartyRegister();\n        message.id = (_a = object.id) !== null && _a !== void 0 ? _a : 0;\n        message.ver = (_b = object.ver) !== null && _b !== void 0 ? _b : 0;\n        message.apr = (_c = object.apr) !== null && _c !== void 0 ? _c : 0;\n        message.ark = (_d = object.ark) !== null && _d !== void 0 ? _d : 0;\n        message.nby = (_e = object.nby) !== null && _e !== void 0 ? _e : 0;\n        message.grp = (_f = object.grp) !== null && _f !== void 0 ? _f : 0;\n        message.slots = (_g = object.slots) !== null && _g !== void 0 ? _g : 0;\n        message.launcher = (_h = object.launcher) !== null && _h !== void 0 ? _h : 0;\n        message.gameType = (_j = object.gameType) !== null && _j !== void 0 ? _j : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2PartySearch() {\n    return { ver: 0, apr: 0, ark: 0, grps: [], launcher: 0, gameType: 0 };\n}\nexports.CMsgGCCStrike15V2PartySearch = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.ver !== 0) {\n            writer.uint32(8).uint32(message.ver);\n        }\n        if (message.apr !== 0) {\n            writer.uint32(16).uint32(message.apr);\n        }\n        if (message.ark !== 0) {\n            writer.uint32(24).uint32(message.ark);\n        }\n        writer.uint32(34).fork();\n        for (const v of message.grps) {\n            writer.uint32(v);\n        }\n        writer.ldelim();\n        if (message.launcher !== 0) {\n            writer.uint32(40).uint32(message.launcher);\n        }\n        if (message.gameType !== 0) {\n            writer.uint32(48).uint32(message.gameType);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2PartySearch();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.ver = reader.uint32();\n                    break;\n                case 2:\n                    message.apr = reader.uint32();\n                    break;\n                case 3:\n                    message.ark = reader.uint32();\n                    break;\n                case 4:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.grps.push(reader.uint32());\n                        }\n                    }\n                    else {\n                        message.grps.push(reader.uint32());\n                    }\n                    break;\n                case 5:\n                    message.launcher = reader.uint32();\n                    break;\n                case 6:\n                    message.gameType = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f;\n        const message = createBaseCMsgGCCStrike15V2PartySearch();\n        message.ver = (_a = object.ver) !== null && _a !== void 0 ? _a : 0;\n        message.apr = (_b = object.apr) !== null && _b !== void 0 ? _b : 0;\n        message.ark = (_c = object.ark) !== null && _c !== void 0 ? _c : 0;\n        message.grps = ((_d = object.grps) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];\n        message.launcher = (_e = object.launcher) !== null && _e !== void 0 ? _e : 0;\n        message.gameType = (_f = object.gameType) !== null && _f !== void 0 ? _f : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2PartySearchResults() {\n    return { entries: [] };\n}\nexports.CMsgGCCStrike15V2PartySearchResults = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.entries) {\n            exports.CMsgGCCStrike15V2PartySearchResults_Entry.encode(v, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2PartySearchResults();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.entries.push(exports.CMsgGCCStrike15V2PartySearchResults_Entry.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2PartySearchResults();\n        message.entries =\n            ((_a = object.entries) === null || _a === void 0 ? void 0 : _a.map(e => exports.CMsgGCCStrike15V2PartySearchResults_Entry.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2PartySearchResults_Entry() {\n    return { id: 0, grp: 0, gameType: 0, apr: 0, ark: 0, loc: 0, accountid: 0 };\n}\nexports.CMsgGCCStrike15V2PartySearchResults_Entry = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.id !== 0) {\n            writer.uint32(8).uint32(message.id);\n        }\n        if (message.grp !== 0) {\n            writer.uint32(16).uint32(message.grp);\n        }\n        if (message.gameType !== 0) {\n            writer.uint32(24).uint32(message.gameType);\n        }\n        if (message.apr !== 0) {\n            writer.uint32(32).uint32(message.apr);\n        }\n        if (message.ark !== 0) {\n            writer.uint32(40).uint32(message.ark);\n        }\n        if (message.loc !== 0) {\n            writer.uint32(48).uint32(message.loc);\n        }\n        if (message.accountid !== 0) {\n            writer.uint32(56).uint32(message.accountid);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2PartySearchResults_Entry();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.id = reader.uint32();\n                    break;\n                case 2:\n                    message.grp = reader.uint32();\n                    break;\n                case 3:\n                    message.gameType = reader.uint32();\n                    break;\n                case 4:\n                    message.apr = reader.uint32();\n                    break;\n                case 5:\n                    message.ark = reader.uint32();\n                    break;\n                case 6:\n                    message.loc = reader.uint32();\n                    break;\n                case 7:\n                    message.accountid = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g;\n        const message = createBaseCMsgGCCStrike15V2PartySearchResults_Entry();\n        message.id = (_a = object.id) !== null && _a !== void 0 ? _a : 0;\n        message.grp = (_b = object.grp) !== null && _b !== void 0 ? _b : 0;\n        message.gameType = (_c = object.gameType) !== null && _c !== void 0 ? _c : 0;\n        message.apr = (_d = object.apr) !== null && _d !== void 0 ? _d : 0;\n        message.ark = (_e = object.ark) !== null && _e !== void 0 ? _e : 0;\n        message.loc = (_f = object.loc) !== null && _f !== void 0 ? _f : 0;\n        message.accountid = (_g = object.accountid) !== null && _g !== void 0 ? _g : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2PartyInvite() {\n    return { accountid: 0, lobbyid: 0 };\n}\nexports.CMsgGCCStrike15V2PartyInvite = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountid !== 0) {\n            writer.uint32(8).uint32(message.accountid);\n        }\n        if (message.lobbyid !== 0) {\n            writer.uint32(16).uint32(message.lobbyid);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2PartyInvite();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountid = reader.uint32();\n                    break;\n                case 2:\n                    message.lobbyid = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2PartyInvite();\n        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;\n        message.lobbyid = (_b = object.lobbyid) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2AccountRequestCoPlays() {\n    return { players: [], servertime: 0 };\n}\nexports.CMsgGCCStrike15V2AccountRequestCoPlays = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.players) {\n            exports.CMsgGCCStrike15V2AccountRequestCoPlays_Player.encode(v, writer.uint32(10).fork()).ldelim();\n        }\n        if (message.servertime !== 0) {\n            writer.uint32(16).uint32(message.servertime);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2AccountRequestCoPlays();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.players.push(exports.CMsgGCCStrike15V2AccountRequestCoPlays_Player.decode(reader, reader.uint32()));\n                    break;\n                case 2:\n                    message.servertime = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2AccountRequestCoPlays();\n        message.players =\n            ((_a = object.players) === null || _a === void 0 ? void 0 : _a.map(e => exports.CMsgGCCStrike15V2AccountRequestCoPlays_Player.fromPartial(e))) || [];\n        message.servertime = (_b = object.servertime) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2AccountRequestCoPlays_Player() {\n    return { accountid: 0, rtcoplay: 0, online: false };\n}\nexports.CMsgGCCStrike15V2AccountRequestCoPlays_Player = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountid !== 0) {\n            writer.uint32(8).uint32(message.accountid);\n        }\n        if (message.rtcoplay !== 0) {\n            writer.uint32(16).uint32(message.rtcoplay);\n        }\n        if (message.online === true) {\n            writer.uint32(24).bool(message.online);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2AccountRequestCoPlays_Player();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountid = reader.uint32();\n                    break;\n                case 2:\n                    message.rtcoplay = reader.uint32();\n                    break;\n                case 3:\n                    message.online = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCMsgGCCStrike15V2AccountRequestCoPlays_Player();\n        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;\n        message.rtcoplay = (_b = object.rtcoplay) !== null && _b !== void 0 ? _b : 0;\n        message.online = (_c = object.online) !== null && _c !== void 0 ? _c : false;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientToGCRequestTicket() {\n    return {\n        authorizedSteamId: Long.UZERO,\n        authorizedPublicIp: 0,\n        gameserverSteamId: Long.UZERO,\n        gameserverSdrRouting: \"\"\n    };\n}\nexports.CMsgGCCStrike15V2ClientToGCRequestTicket = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.authorizedSteamId.isZero()) {\n            writer.uint32(9).fixed64(message.authorizedSteamId);\n        }\n        if (message.authorizedPublicIp !== 0) {\n            writer.uint32(21).fixed32(message.authorizedPublicIp);\n        }\n        if (!message.gameserverSteamId.isZero()) {\n            writer.uint32(25).fixed64(message.gameserverSteamId);\n        }\n        if (message.gameserverSdrRouting !== \"\") {\n            writer.uint32(42).string(message.gameserverSdrRouting);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientToGCRequestTicket();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.authorizedSteamId = reader.fixed64();\n                    break;\n                case 2:\n                    message.authorizedPublicIp = reader.fixed32();\n                    break;\n                case 3:\n                    message.gameserverSteamId = reader.fixed64();\n                    break;\n                case 5:\n                    message.gameserverSdrRouting = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2ClientToGCRequestTicket();\n        message.authorizedSteamId =\n            object.authorizedSteamId !== undefined &&\n                object.authorizedSteamId !== null\n                ? Long.fromValue(object.authorizedSteamId)\n                : Long.UZERO;\n        message.authorizedPublicIp = (_a = object.authorizedPublicIp) !== null && _a !== void 0 ? _a : 0;\n        message.gameserverSteamId =\n            object.gameserverSteamId !== undefined &&\n                object.gameserverSteamId !== null\n                ? Long.fromValue(object.gameserverSteamId)\n                : Long.UZERO;\n        message.gameserverSdrRouting = (_b = object.gameserverSdrRouting) !== null && _b !== void 0 ? _b : \"\";\n        return message;\n    }\n};\nfunction createBaseCMsgGCToClientSteamDatagramTicket() {\n    return { serializedTicket: new Uint8Array() };\n}\nexports.CMsgGCToClientSteamDatagramTicket = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.serializedTicket.length !== 0) {\n            writer.uint32(130).bytes(message.serializedTicket);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCToClientSteamDatagramTicket();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 16:\n                    message.serializedTicket = reader.bytes();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCToClientSteamDatagramTicket();\n        message.serializedTicket = (_a = object.serializedTicket) !== null && _a !== void 0 ? _a : new Uint8Array();\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientRequestOffers() {\n    return {};\n}\nexports.CMsgGCCStrike15V2ClientRequestOffers = {\n    encode(_, writer = minimal_1.Writer.create()) {\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientRequestOffers();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(_) {\n        const message = createBaseCMsgGCCStrike15V2ClientRequestOffers();\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientRequestSouvenir() {\n    return { itemid: Long.UZERO, matchid: Long.UZERO, eventid: 0 };\n}\nexports.CMsgGCCStrike15V2ClientRequestSouvenir = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.itemid.isZero()) {\n            writer.uint32(8).uint64(message.itemid);\n        }\n        if (!message.matchid.isZero()) {\n            writer.uint32(16).uint64(message.matchid);\n        }\n        if (message.eventid !== 0) {\n            writer.uint32(24).int32(message.eventid);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientRequestSouvenir();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.itemid = reader.uint64();\n                    break;\n                case 2:\n                    message.matchid = reader.uint64();\n                    break;\n                case 3:\n                    message.eventid = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2ClientRequestSouvenir();\n        message.itemid =\n            object.itemid !== undefined && object.itemid !== null\n                ? Long.fromValue(object.itemid)\n                : Long.UZERO;\n        message.matchid =\n            object.matchid !== undefined && object.matchid !== null\n                ? Long.fromValue(object.matchid)\n                : Long.UZERO;\n        message.eventid = (_a = object.eventid) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientAccountBalance() {\n    return { amount: Long.UZERO, url: \"\" };\n}\nexports.CMsgGCCStrike15V2ClientAccountBalance = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.amount.isZero()) {\n            writer.uint32(8).uint64(message.amount);\n        }\n        if (message.url !== \"\") {\n            writer.uint32(18).string(message.url);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientAccountBalance();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.amount = reader.uint64();\n                    break;\n                case 2:\n                    message.url = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2ClientAccountBalance();\n        message.amount =\n            object.amount !== undefined && object.amount !== null\n                ? Long.fromValue(object.amount)\n                : Long.UZERO;\n        message.url = (_a = object.url) !== null && _a !== void 0 ? _a : \"\";\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientPartyJoinRelay() {\n    return { accountid: 0, lobbyid: Long.UZERO };\n}\nexports.CMsgGCCStrike15V2ClientPartyJoinRelay = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountid !== 0) {\n            writer.uint32(8).uint32(message.accountid);\n        }\n        if (!message.lobbyid.isZero()) {\n            writer.uint32(16).uint64(message.lobbyid);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientPartyJoinRelay();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountid = reader.uint32();\n                    break;\n                case 2:\n                    message.lobbyid = reader.uint64();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2ClientPartyJoinRelay();\n        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;\n        message.lobbyid =\n            object.lobbyid !== undefined && object.lobbyid !== null\n                ? Long.fromValue(object.lobbyid)\n                : Long.UZERO;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientPartyWarning() {\n    return { entries: [] };\n}\nexports.CMsgGCCStrike15V2ClientPartyWarning = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.entries) {\n            exports.CMsgGCCStrike15V2ClientPartyWarning_Entry.encode(v, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientPartyWarning();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.entries.push(exports.CMsgGCCStrike15V2ClientPartyWarning_Entry.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2ClientPartyWarning();\n        message.entries =\n            ((_a = object.entries) === null || _a === void 0 ? void 0 : _a.map(e => exports.CMsgGCCStrike15V2ClientPartyWarning_Entry.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientPartyWarning_Entry() {\n    return { accountid: 0, warntype: 0 };\n}\nexports.CMsgGCCStrike15V2ClientPartyWarning_Entry = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountid !== 0) {\n            writer.uint32(8).uint32(message.accountid);\n        }\n        if (message.warntype !== 0) {\n            writer.uint32(16).uint32(message.warntype);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientPartyWarning_Entry();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountid = reader.uint32();\n                    break;\n                case 2:\n                    message.warntype = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2ClientPartyWarning_Entry();\n        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;\n        message.warntype = (_b = object.warntype) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2SetEventFavorite() {\n    return { eventid: Long.UZERO, isFavorite: false };\n}\nexports.CMsgGCCStrike15V2SetEventFavorite = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.eventid.isZero()) {\n            writer.uint32(8).uint64(message.eventid);\n        }\n        if (message.isFavorite === true) {\n            writer.uint32(16).bool(message.isFavorite);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2SetEventFavorite();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.eventid = reader.uint64();\n                    break;\n                case 2:\n                    message.isFavorite = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2SetEventFavorite();\n        message.eventid =\n            object.eventid !== undefined && object.eventid !== null\n                ? Long.fromValue(object.eventid)\n                : Long.UZERO;\n        message.isFavorite = (_a = object.isFavorite) !== null && _a !== void 0 ? _a : false;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2GetEventFavoritesRequest() {\n    return { allEvents: false };\n}\nexports.CMsgGCCStrike15V2GetEventFavoritesRequest = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.allEvents === true) {\n            writer.uint32(8).bool(message.allEvents);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2GetEventFavoritesRequest();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.allEvents = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2GetEventFavoritesRequest();\n        message.allEvents = (_a = object.allEvents) !== null && _a !== void 0 ? _a : false;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2GetEventFavoritesResponse() {\n    return { allEvents: false, jsonFavorites: \"\", jsonFeatured: \"\" };\n}\nexports.CMsgGCCStrike15V2GetEventFavoritesResponse = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.allEvents === true) {\n            writer.uint32(8).bool(message.allEvents);\n        }\n        if (message.jsonFavorites !== \"\") {\n            writer.uint32(18).string(message.jsonFavorites);\n        }\n        if (message.jsonFeatured !== \"\") {\n            writer.uint32(26).string(message.jsonFeatured);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2GetEventFavoritesResponse();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.allEvents = reader.bool();\n                    break;\n                case 2:\n                    message.jsonFavorites = reader.string();\n                    break;\n                case 3:\n                    message.jsonFeatured = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCMsgGCCStrike15V2GetEventFavoritesResponse();\n        message.allEvents = (_a = object.allEvents) !== null && _a !== void 0 ? _a : false;\n        message.jsonFavorites = (_b = object.jsonFavorites) !== null && _b !== void 0 ? _b : \"\";\n        message.jsonFeatured = (_c = object.jsonFeatured) !== null && _c !== void 0 ? _c : \"\";\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientPerfReport() {\n    return { entries: [] };\n}\nexports.CMsgGCCStrike15V2ClientPerfReport = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.entries) {\n            exports.CMsgGCCStrike15V2ClientPerfReport_Entry.encode(v, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientPerfReport();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.entries.push(exports.CMsgGCCStrike15V2ClientPerfReport_Entry.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgGCCStrike15V2ClientPerfReport();\n        message.entries =\n            ((_a = object.entries) === null || _a === void 0 ? void 0 : _a.map(e => exports.CMsgGCCStrike15V2ClientPerfReport_Entry.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientPerfReport_Entry() {\n    return {\n        perfcounter: 0,\n        length: 0,\n        reference: new Uint8Array(),\n        actual: new Uint8Array(),\n        sourceid: 0,\n        status: 0\n    };\n}\nexports.CMsgGCCStrike15V2ClientPerfReport_Entry = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.perfcounter !== 0) {\n            writer.uint32(8).uint32(message.perfcounter);\n        }\n        if (message.length !== 0) {\n            writer.uint32(16).uint32(message.length);\n        }\n        if (message.reference.length !== 0) {\n            writer.uint32(26).bytes(message.reference);\n        }\n        if (message.actual.length !== 0) {\n            writer.uint32(34).bytes(message.actual);\n        }\n        if (message.sourceid !== 0) {\n            writer.uint32(40).uint32(message.sourceid);\n        }\n        if (message.status !== 0) {\n            writer.uint32(48).uint32(message.status);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientPerfReport_Entry();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.perfcounter = reader.uint32();\n                    break;\n                case 2:\n                    message.length = reader.uint32();\n                    break;\n                case 3:\n                    message.reference = reader.bytes();\n                    break;\n                case 4:\n                    message.actual = reader.bytes();\n                    break;\n                case 5:\n                    message.sourceid = reader.uint32();\n                    break;\n                case 6:\n                    message.status = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f;\n        const message = createBaseCMsgGCCStrike15V2ClientPerfReport_Entry();\n        message.perfcounter = (_a = object.perfcounter) !== null && _a !== void 0 ? _a : 0;\n        message.length = (_b = object.length) !== null && _b !== void 0 ? _b : 0;\n        message.reference = (_c = object.reference) !== null && _c !== void 0 ? _c : new Uint8Array();\n        message.actual = (_d = object.actual) !== null && _d !== void 0 ? _d : new Uint8Array();\n        message.sourceid = (_e = object.sourceid) !== null && _e !== void 0 ? _e : 0;\n        message.status = (_f = object.status) !== null && _f !== void 0 ? _f : 0;\n        return message;\n    }\n};\nfunction createBaseCVDiagnostic() {\n    return { id: 0, extended: 0, value: Long.UZERO, stringValue: \"\" };\n}\nexports.CVDiagnostic = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.id !== 0) {\n            writer.uint32(8).uint32(message.id);\n        }\n        if (message.extended !== 0) {\n            writer.uint32(16).uint32(message.extended);\n        }\n        if (!message.value.isZero()) {\n            writer.uint32(24).uint64(message.value);\n        }\n        if (message.stringValue !== \"\") {\n            writer.uint32(34).string(message.stringValue);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCVDiagnostic();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.id = reader.uint32();\n                    break;\n                case 2:\n                    message.extended = reader.uint32();\n                    break;\n                case 3:\n                    message.value = reader.uint64();\n                    break;\n                case 4:\n                    message.stringValue = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCVDiagnostic();\n        message.id = (_a = object.id) !== null && _a !== void 0 ? _a : 0;\n        message.extended = (_b = object.extended) !== null && _b !== void 0 ? _b : 0;\n        message.value =\n            object.value !== undefined && object.value !== null\n                ? Long.fromValue(object.value)\n                : Long.UZERO;\n        message.stringValue = (_c = object.stringValue) !== null && _c !== void 0 ? _c : \"\";\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2ClientReportValidation() {\n    return {\n        fileReport: \"\",\n        commandLine: \"\",\n        totalFiles: 0,\n        internalError: 0,\n        trustTime: 0,\n        countPending: 0,\n        countCompleted: 0,\n        processId: 0,\n        osversion: 0,\n        clientreportversion: 0,\n        statusId: 0,\n        diagnostic1: 0,\n        diagnostic2: Long.UZERO,\n        diagnostic3: Long.UZERO,\n        lastLaunchData: \"\",\n        reportCount: 0,\n        clientTime: Long.UZERO,\n        diagnostic4: Long.UZERO,\n        diagnostic5: Long.UZERO,\n        diagnostics: []\n    };\n}\nexports.CMsgGCCStrike15V2ClientReportValidation = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.fileReport !== \"\") {\n            writer.uint32(10).string(message.fileReport);\n        }\n        if (message.commandLine !== \"\") {\n            writer.uint32(18).string(message.commandLine);\n        }\n        if (message.totalFiles !== 0) {\n            writer.uint32(24).uint32(message.totalFiles);\n        }\n        if (message.internalError !== 0) {\n            writer.uint32(32).uint32(message.internalError);\n        }\n        if (message.trustTime !== 0) {\n            writer.uint32(40).uint32(message.trustTime);\n        }\n        if (message.countPending !== 0) {\n            writer.uint32(48).uint32(message.countPending);\n        }\n        if (message.countCompleted !== 0) {\n            writer.uint32(56).uint32(message.countCompleted);\n        }\n        if (message.processId !== 0) {\n            writer.uint32(64).uint32(message.processId);\n        }\n        if (message.osversion !== 0) {\n            writer.uint32(72).int32(message.osversion);\n        }\n        if (message.clientreportversion !== 0) {\n            writer.uint32(80).uint32(message.clientreportversion);\n        }\n        if (message.statusId !== 0) {\n            writer.uint32(88).uint32(message.statusId);\n        }\n        if (message.diagnostic1 !== 0) {\n            writer.uint32(96).uint32(message.diagnostic1);\n        }\n        if (!message.diagnostic2.isZero()) {\n            writer.uint32(104).uint64(message.diagnostic2);\n        }\n        if (!message.diagnostic3.isZero()) {\n            writer.uint32(112).uint64(message.diagnostic3);\n        }\n        if (message.lastLaunchData !== \"\") {\n            writer.uint32(122).string(message.lastLaunchData);\n        }\n        if (message.reportCount !== 0) {\n            writer.uint32(128).uint32(message.reportCount);\n        }\n        if (!message.clientTime.isZero()) {\n            writer.uint32(136).uint64(message.clientTime);\n        }\n        if (!message.diagnostic4.isZero()) {\n            writer.uint32(144).uint64(message.diagnostic4);\n        }\n        if (!message.diagnostic5.isZero()) {\n            writer.uint32(152).uint64(message.diagnostic5);\n        }\n        for (const v of message.diagnostics) {\n            exports.CVDiagnostic.encode(v, writer.uint32(162).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2ClientReportValidation();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.fileReport = reader.string();\n                    break;\n                case 2:\n                    message.commandLine = reader.string();\n                    break;\n                case 3:\n                    message.totalFiles = reader.uint32();\n                    break;\n                case 4:\n                    message.internalError = reader.uint32();\n                    break;\n                case 5:\n                    message.trustTime = reader.uint32();\n                    break;\n                case 6:\n                    message.countPending = reader.uint32();\n                    break;\n                case 7:\n                    message.countCompleted = reader.uint32();\n                    break;\n                case 8:\n                    message.processId = reader.uint32();\n                    break;\n                case 9:\n                    message.osversion = reader.int32();\n                    break;\n                case 10:\n                    message.clientreportversion = reader.uint32();\n                    break;\n                case 11:\n                    message.statusId = reader.uint32();\n                    break;\n                case 12:\n                    message.diagnostic1 = reader.uint32();\n                    break;\n                case 13:\n                    message.diagnostic2 = reader.uint64();\n                    break;\n                case 14:\n                    message.diagnostic3 = reader.uint64();\n                    break;\n                case 15:\n                    message.lastLaunchData = reader.string();\n                    break;\n                case 16:\n                    message.reportCount = reader.uint32();\n                    break;\n                case 17:\n                    message.clientTime = reader.uint64();\n                    break;\n                case 18:\n                    message.diagnostic4 = reader.uint64();\n                    break;\n                case 19:\n                    message.diagnostic5 = reader.uint64();\n                    break;\n                case 20:\n                    message.diagnostics.push(exports.CVDiagnostic.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;\n        const message = createBaseCMsgGCCStrike15V2ClientReportValidation();\n        message.fileReport = (_a = object.fileReport) !== null && _a !== void 0 ? _a : \"\";\n        message.commandLine = (_b = object.commandLine) !== null && _b !== void 0 ? _b : \"\";\n        message.totalFiles = (_c = object.totalFiles) !== null && _c !== void 0 ? _c : 0;\n        message.internalError = (_d = object.internalError) !== null && _d !== void 0 ? _d : 0;\n        message.trustTime = (_e = object.trustTime) !== null && _e !== void 0 ? _e : 0;\n        message.countPending = (_f = object.countPending) !== null && _f !== void 0 ? _f : 0;\n        message.countCompleted = (_g = object.countCompleted) !== null && _g !== void 0 ? _g : 0;\n        message.processId = (_h = object.processId) !== null && _h !== void 0 ? _h : 0;\n        message.osversion = (_j = object.osversion) !== null && _j !== void 0 ? _j : 0;\n        message.clientreportversion = (_k = object.clientreportversion) !== null && _k !== void 0 ? _k : 0;\n        message.statusId = (_l = object.statusId) !== null && _l !== void 0 ? _l : 0;\n        message.diagnostic1 = (_m = object.diagnostic1) !== null && _m !== void 0 ? _m : 0;\n        message.diagnostic2 =\n            object.diagnostic2 !== undefined && object.diagnostic2 !== null\n                ? Long.fromValue(object.diagnostic2)\n                : Long.UZERO;\n        message.diagnostic3 =\n            object.diagnostic3 !== undefined && object.diagnostic3 !== null\n                ? Long.fromValue(object.diagnostic3)\n                : Long.UZERO;\n        message.lastLaunchData = (_o = object.lastLaunchData) !== null && _o !== void 0 ? _o : \"\";\n        message.reportCount = (_p = object.reportCount) !== null && _p !== void 0 ? _p : 0;\n        message.clientTime =\n            object.clientTime !== undefined && object.clientTime !== null\n                ? Long.fromValue(object.clientTime)\n                : Long.UZERO;\n        message.diagnostic4 =\n            object.diagnostic4 !== undefined && object.diagnostic4 !== null\n                ? Long.fromValue(object.diagnostic4)\n                : Long.UZERO;\n        message.diagnostic5 =\n            object.diagnostic5 !== undefined && object.diagnostic5 !== null\n                ? Long.fromValue(object.diagnostic5)\n                : Long.UZERO;\n        message.diagnostics =\n            ((_q = object.diagnostics) === null || _q === void 0 ? void 0 : _q.map(e => exports.CVDiagnostic.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2GC2ClientRefuseSecureMode() {\n    return {\n        fileReport: \"\",\n        offerInsecureMode: false,\n        offerSecureMode: false,\n        showUnsignedUi: false,\n        kickUser: false,\n        showTrustedUi: false,\n        showWarningNotTrusted: false,\n        showWarningNotTrusted2: false,\n        filesPreventedTrusted: \"\"\n    };\n}\nexports.CMsgGCCStrike15V2GC2ClientRefuseSecureMode = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.fileReport !== \"\") {\n            writer.uint32(10).string(message.fileReport);\n        }\n        if (message.offerInsecureMode === true) {\n            writer.uint32(16).bool(message.offerInsecureMode);\n        }\n        if (message.offerSecureMode === true) {\n            writer.uint32(24).bool(message.offerSecureMode);\n        }\n        if (message.showUnsignedUi === true) {\n            writer.uint32(32).bool(message.showUnsignedUi);\n        }\n        if (message.kickUser === true) {\n            writer.uint32(40).bool(message.kickUser);\n        }\n        if (message.showTrustedUi === true) {\n            writer.uint32(48).bool(message.showTrustedUi);\n        }\n        if (message.showWarningNotTrusted === true) {\n            writer.uint32(56).bool(message.showWarningNotTrusted);\n        }\n        if (message.showWarningNotTrusted2 === true) {\n            writer.uint32(64).bool(message.showWarningNotTrusted2);\n        }\n        if (message.filesPreventedTrusted !== \"\") {\n            writer.uint32(74).string(message.filesPreventedTrusted);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2GC2ClientRefuseSecureMode();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.fileReport = reader.string();\n                    break;\n                case 2:\n                    message.offerInsecureMode = reader.bool();\n                    break;\n                case 3:\n                    message.offerSecureMode = reader.bool();\n                    break;\n                case 4:\n                    message.showUnsignedUi = reader.bool();\n                    break;\n                case 5:\n                    message.kickUser = reader.bool();\n                    break;\n                case 6:\n                    message.showTrustedUi = reader.bool();\n                    break;\n                case 7:\n                    message.showWarningNotTrusted = reader.bool();\n                    break;\n                case 8:\n                    message.showWarningNotTrusted2 = reader.bool();\n                    break;\n                case 9:\n                    message.filesPreventedTrusted = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j;\n        const message = createBaseCMsgGCCStrike15V2GC2ClientRefuseSecureMode();\n        message.fileReport = (_a = object.fileReport) !== null && _a !== void 0 ? _a : \"\";\n        message.offerInsecureMode = (_b = object.offerInsecureMode) !== null && _b !== void 0 ? _b : false;\n        message.offerSecureMode = (_c = object.offerSecureMode) !== null && _c !== void 0 ? _c : false;\n        message.showUnsignedUi = (_d = object.showUnsignedUi) !== null && _d !== void 0 ? _d : false;\n        message.kickUser = (_e = object.kickUser) !== null && _e !== void 0 ? _e : false;\n        message.showTrustedUi = (_f = object.showTrustedUi) !== null && _f !== void 0 ? _f : false;\n        message.showWarningNotTrusted = (_g = object.showWarningNotTrusted) !== null && _g !== void 0 ? _g : false;\n        message.showWarningNotTrusted2 = (_h = object.showWarningNotTrusted2) !== null && _h !== void 0 ? _h : false;\n        message.filesPreventedTrusted = (_j = object.filesPreventedTrusted) !== null && _j !== void 0 ? _j : \"\";\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2GC2ClientRequestValidation() {\n    return { fullReport: false, module: \"\" };\n}\nexports.CMsgGCCStrike15V2GC2ClientRequestValidation = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.fullReport === true) {\n            writer.uint32(8).bool(message.fullReport);\n        }\n        if (message.module !== \"\") {\n            writer.uint32(18).string(message.module);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2GC2ClientRequestValidation();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.fullReport = reader.bool();\n                    break;\n                case 2:\n                    message.module = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgGCCStrike15V2GC2ClientRequestValidation();\n        message.fullReport = (_a = object.fullReport) !== null && _a !== void 0 ? _a : false;\n        message.module = (_b = object.module) !== null && _b !== void 0 ? _b : \"\";\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2GC2ClientInitSystem() {\n    return {\n        load: false,\n        name: \"\",\n        outputname: \"\",\n        keyData: new Uint8Array(),\n        shaHash: new Uint8Array(),\n        cookie: 0,\n        manifest: \"\",\n        systemPackage: new Uint8Array(),\n        loadSystem: false\n    };\n}\nexports.CMsgGCCStrike15V2GC2ClientInitSystem = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.load === true) {\n            writer.uint32(8).bool(message.load);\n        }\n        if (message.name !== \"\") {\n            writer.uint32(18).string(message.name);\n        }\n        if (message.outputname !== \"\") {\n            writer.uint32(26).string(message.outputname);\n        }\n        if (message.keyData.length !== 0) {\n            writer.uint32(34).bytes(message.keyData);\n        }\n        if (message.shaHash.length !== 0) {\n            writer.uint32(42).bytes(message.shaHash);\n        }\n        if (message.cookie !== 0) {\n            writer.uint32(48).int32(message.cookie);\n        }\n        if (message.manifest !== \"\") {\n            writer.uint32(58).string(message.manifest);\n        }\n        if (message.systemPackage.length !== 0) {\n            writer.uint32(66).bytes(message.systemPackage);\n        }\n        if (message.loadSystem === true) {\n            writer.uint32(72).bool(message.loadSystem);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2GC2ClientInitSystem();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.load = reader.bool();\n                    break;\n                case 2:\n                    message.name = reader.string();\n                    break;\n                case 3:\n                    message.outputname = reader.string();\n                    break;\n                case 4:\n                    message.keyData = reader.bytes();\n                    break;\n                case 5:\n                    message.shaHash = reader.bytes();\n                    break;\n                case 6:\n                    message.cookie = reader.int32();\n                    break;\n                case 7:\n                    message.manifest = reader.string();\n                    break;\n                case 8:\n                    message.systemPackage = reader.bytes();\n                    break;\n                case 9:\n                    message.loadSystem = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j;\n        const message = createBaseCMsgGCCStrike15V2GC2ClientInitSystem();\n        message.load = (_a = object.load) !== null && _a !== void 0 ? _a : false;\n        message.name = (_b = object.name) !== null && _b !== void 0 ? _b : \"\";\n        message.outputname = (_c = object.outputname) !== null && _c !== void 0 ? _c : \"\";\n        message.keyData = (_d = object.keyData) !== null && _d !== void 0 ? _d : new Uint8Array();\n        message.shaHash = (_e = object.shaHash) !== null && _e !== void 0 ? _e : new Uint8Array();\n        message.cookie = (_f = object.cookie) !== null && _f !== void 0 ? _f : 0;\n        message.manifest = (_g = object.manifest) !== null && _g !== void 0 ? _g : \"\";\n        message.systemPackage = (_h = object.systemPackage) !== null && _h !== void 0 ? _h : new Uint8Array();\n        message.loadSystem = (_j = object.loadSystem) !== null && _j !== void 0 ? _j : false;\n        return message;\n    }\n};\nfunction createBaseCMsgGCCStrike15V2GC2ClientInitSystemResponse() {\n    return {\n        success: false,\n        diagnostic: \"\",\n        shaHash: new Uint8Array(),\n        response: 0,\n        errorCode1: 0,\n        errorCode2: 0,\n        handle: Long.ZERO,\n        einitResult: 0,\n        auxSystem1: 0,\n        auxSystem2: 0\n    };\n}\nexports.CMsgGCCStrike15V2GC2ClientInitSystemResponse = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.success === true) {\n            writer.uint32(8).bool(message.success);\n        }\n        if (message.diagnostic !== \"\") {\n            writer.uint32(18).string(message.diagnostic);\n        }\n        if (message.shaHash.length !== 0) {\n            writer.uint32(26).bytes(message.shaHash);\n        }\n        if (message.response !== 0) {\n            writer.uint32(32).int32(message.response);\n        }\n        if (message.errorCode1 !== 0) {\n            writer.uint32(40).int32(message.errorCode1);\n        }\n        if (message.errorCode2 !== 0) {\n            writer.uint32(48).int32(message.errorCode2);\n        }\n        if (!message.handle.isZero()) {\n            writer.uint32(56).int64(message.handle);\n        }\n        if (message.einitResult !== 0) {\n            writer.uint32(64).int32(message.einitResult);\n        }\n        if (message.auxSystem1 !== 0) {\n            writer.uint32(72).int32(message.auxSystem1);\n        }\n        if (message.auxSystem2 !== 0) {\n            writer.uint32(80).int32(message.auxSystem2);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgGCCStrike15V2GC2ClientInitSystemResponse();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.success = reader.bool();\n                    break;\n                case 2:\n                    message.diagnostic = reader.string();\n                    break;\n                case 3:\n                    message.shaHash = reader.bytes();\n                    break;\n                case 4:\n                    message.response = reader.int32();\n                    break;\n                case 5:\n                    message.errorCode1 = reader.int32();\n                    break;\n                case 6:\n                    message.errorCode2 = reader.int32();\n                    break;\n                case 7:\n                    message.handle = reader.int64();\n                    break;\n                case 8:\n                    message.einitResult = reader.int32();\n                    break;\n                case 9:\n                    message.auxSystem1 = reader.int32();\n                    break;\n                case 10:\n                    message.auxSystem2 = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j;\n        const message = createBaseCMsgGCCStrike15V2GC2ClientInitSystemResponse();\n        message.success = (_a = object.success) !== null && _a !== void 0 ? _a : false;\n        message.diagnostic = (_b = object.diagnostic) !== null && _b !== void 0 ? _b : \"\";\n        message.shaHash = (_c = object.shaHash) !== null && _c !== void 0 ? _c : new Uint8Array();\n        message.response = (_d = object.response) !== null && _d !== void 0 ? _d : 0;\n        message.errorCode1 = (_e = object.errorCode1) !== null && _e !== void 0 ? _e : 0;\n        message.errorCode2 = (_f = object.errorCode2) !== null && _f !== void 0 ? _f : 0;\n        message.handle =\n            object.handle !== undefined && object.handle !== null\n                ? Long.fromValue(object.handle)\n                : Long.ZERO;\n        message.einitResult = (_g = object.einitResult) !== null && _g !== void 0 ? _g : 0;\n        message.auxSystem1 = (_h = object.auxSystem1) !== null && _h !== void 0 ? _h : 0;\n        message.auxSystem2 = (_j = object.auxSystem2) !== null && _j !== void 0 ? _j : 0;\n        return message;\n    }\n};\n// If you get a compile-error about 'Constructor<Long> and ... have no overlap',\n// add '--ts_proto_opt=esModuleInterop=true' as a flag when calling 'protoc'.\nif (minimal_1.util.Long !== Long) {\n    minimal_1.util.Long = Long;\n    (0, minimal_1.configure)();\n}\n//# sourceMappingURL=cstrike15_gcmessages.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.CCSUsrMsgVoteStart = exports.CCSUsrMsgCallVoteFailed = exports.CCSUsrMsgXRankUpd = exports.CCSUsrMsgXRankGet = exports.CCSUsrMsgPlayerDecalDigitalSignature = exports.CCSUsrMsgScoreLeaderboardData = exports.CCSUsrMsgQuestProgress = exports.CCSUsrMsgDisplayInventory = exports.CCSUsrMsgPlayerStatsUpdate_Stat = exports.CCSUsrMsgPlayerStatsUpdate = exports.CCSUsrMsgMatchEndConditions = exports.CCSUsrMsgAchievementEvent = exports.CCSUsrMsgCurrentTimescale = exports.CCSUsrMsgDesiredTimescale = exports.CCSUsrMsgKillCam = exports.CCSUsrMsgReportHit = exports.CCSUsrMsgAdjustMoney = exports.CCSUsrMsgEntityOutlineHighlight = exports.CCSUsrMsgUpdateScreenHealthBar = exports.CCSUsrMsgWeaponSound = exports.CCSUsrMsgReloadEffect = exports.CCSUsrMsgSendPlayerItemFound = exports.CCSUsrMsgSendPlayerItemDrops = exports.CCSUsrMsgProcessSpottedEntityUpdate_SpottedEntityUpdate = exports.CCSUsrMsgProcessSpottedEntityUpdate = exports.CCSUsrMsgKeyHintText = exports.CCSUsrMsgHintText = exports.CCSUsrMsgRadioText = exports.CCSUsrMsgDamage = exports.CCSUsrMsgVoiceMask_PlayerMask = exports.CCSUsrMsgVoiceMask = exports.CCSUsrMsgRawAudio = exports.CCSUsrMsgSendAudio = exports.CCSUsrMsgCloseCaptionDirect = exports.CCSUsrMsgCloseCaption = exports.CCSUsrMsgRumble = exports.CCSUsrMsgFade = exports.CCSUsrMsgShake = exports.CCSUsrMsgHudMsg = exports.CCSUsrMsgTextMsg = exports.CCSUsrMsgSayText2 = exports.CCSUsrMsgSayText = exports.CCSUsrMsgHudText = exports.CCSUsrMsgTrain = exports.CCSUsrMsgGeiger = exports.CCSUsrMsgVGUIMenu_Subkey = exports.CCSUsrMsgVGUIMenu = exports.ECSUsrMsgDisconnectToLobbyAction = exports.ECstrike15UserMessages = exports.protobufPackage = void 0;\nexports.CCSUsrMsgUtilMsg = exports.CCSUsrMsgServerRankRevealAll = exports.CCSUsrMsgClientInfo = exports.CCSUsrMsgWarmupHasEnded = exports.CCSUsrMsgDisconnectToLobby = exports.CCSUsrMsgStopSpectatorMode = exports.CCSUsrMsgRequestState = exports.CCSUsrMsgGameTitle = exports.CCSUsrMsgResetHud = exports.CCSUsrMsgDeepStats = exports.CCSUsrMsgCurrentRoundOdds = exports.CCSUsrMsgRoundImpactScoreData_InitialConditions = exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Damage = exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Objective = exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Victim = exports.CCSUsrMsgRoundImpactScoreData_RisEvent = exports.CCSUsrMsgRoundImpactScoreData = exports.CCSUsrMsgEndOfMatchAllPlayersData_PlayerData = exports.CCSUsrMsgEndOfMatchAllPlayersData_Accolade = exports.CCSUsrMsgEndOfMatchAllPlayersData = exports.CCSUsrMsgSurvivalStats_Damage = exports.CCSUsrMsgSurvivalStats_Placement = exports.CCSUsrMsgSurvivalStats_Fact = exports.CCSUsrMsgSurvivalStats = exports.CCSUsrMsgSSUI = exports.CCSUsrMsgRoundBackupFilenames = exports.CCSUsrMsgGlowPropTurnOff = exports.CCSUsrMsgItemDrop = exports.CCSUsrMsgMatchStatsUpdate = exports.CCSUsrMsgMarkAchievement = exports.CCSUsrMsgAmmoDenied = exports.CCSUsrMsgBarTime = exports.CCSUsrMsgShowMenu = exports.CCSUsrMsgItemPickup = exports.CCSUsrMsgXpUpdate = exports.CCSUsrMsgServerRankUpdate_RankUpdate = exports.CCSUsrMsgServerRankUpdate = exports.CCSUsrMsgSendLastKillerDamageToClient = exports.CCSUsrMsgVoteSetup = exports.CCSUsrMsgVoteFailed = exports.CCSUsrMsgVotePass = void 0;\n/* eslint-disable */\nconst minimal_1 = require(\"protobufjs/minimal\");\nconst Long = require(\"long\");\nconst netmessages_1 = require(\"./netmessages\");\nconst cstrike15_gcmessages_1 = require(\"./cstrike15_gcmessages\");\nexports.protobufPackage = \"\";\nvar ECstrike15UserMessages;\n(function (ECstrike15UserMessages) {\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_VGUIMenu\"] = 1] = \"CS_UM_VGUIMenu\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_Geiger\"] = 2] = \"CS_UM_Geiger\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_Train\"] = 3] = \"CS_UM_Train\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_HudText\"] = 4] = \"CS_UM_HudText\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_SayText\"] = 5] = \"CS_UM_SayText\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_SayText2\"] = 6] = \"CS_UM_SayText2\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_TextMsg\"] = 7] = \"CS_UM_TextMsg\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_HudMsg\"] = 8] = \"CS_UM_HudMsg\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_ResetHud\"] = 9] = \"CS_UM_ResetHud\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_GameTitle\"] = 10] = \"CS_UM_GameTitle\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_Shake\"] = 12] = \"CS_UM_Shake\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_Fade\"] = 13] = \"CS_UM_Fade\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_Rumble\"] = 14] = \"CS_UM_Rumble\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_CloseCaption\"] = 15] = \"CS_UM_CloseCaption\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_CloseCaptionDirect\"] = 16] = \"CS_UM_CloseCaptionDirect\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_SendAudio\"] = 17] = \"CS_UM_SendAudio\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_RawAudio\"] = 18] = \"CS_UM_RawAudio\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_VoiceMask\"] = 19] = \"CS_UM_VoiceMask\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_RequestState\"] = 20] = \"CS_UM_RequestState\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_Damage\"] = 21] = \"CS_UM_Damage\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_RadioText\"] = 22] = \"CS_UM_RadioText\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_HintText\"] = 23] = \"CS_UM_HintText\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_KeyHintText\"] = 24] = \"CS_UM_KeyHintText\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_ProcessSpottedEntityUpdate\"] = 25] = \"CS_UM_ProcessSpottedEntityUpdate\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_ReloadEffect\"] = 26] = \"CS_UM_ReloadEffect\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_AdjustMoney\"] = 27] = \"CS_UM_AdjustMoney\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_UpdateTeamMoney\"] = 28] = \"CS_UM_UpdateTeamMoney\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_StopSpectatorMode\"] = 29] = \"CS_UM_StopSpectatorMode\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_KillCam\"] = 30] = \"CS_UM_KillCam\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_DesiredTimescale\"] = 31] = \"CS_UM_DesiredTimescale\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_CurrentTimescale\"] = 32] = \"CS_UM_CurrentTimescale\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_AchievementEvent\"] = 33] = \"CS_UM_AchievementEvent\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_MatchEndConditions\"] = 34] = \"CS_UM_MatchEndConditions\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_DisconnectToLobby\"] = 35] = \"CS_UM_DisconnectToLobby\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_PlayerStatsUpdate\"] = 36] = \"CS_UM_PlayerStatsUpdate\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_DisplayInventory\"] = 37] = \"CS_UM_DisplayInventory\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_WarmupHasEnded\"] = 38] = \"CS_UM_WarmupHasEnded\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_ClientInfo\"] = 39] = \"CS_UM_ClientInfo\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_XRankGet\"] = 40] = \"CS_UM_XRankGet\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_XRankUpd\"] = 41] = \"CS_UM_XRankUpd\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_CallVoteFailed\"] = 45] = \"CS_UM_CallVoteFailed\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_VoteStart\"] = 46] = \"CS_UM_VoteStart\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_VotePass\"] = 47] = \"CS_UM_VotePass\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_VoteFailed\"] = 48] = \"CS_UM_VoteFailed\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_VoteSetup\"] = 49] = \"CS_UM_VoteSetup\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_ServerRankRevealAll\"] = 50] = \"CS_UM_ServerRankRevealAll\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_SendLastKillerDamageToClient\"] = 51] = \"CS_UM_SendLastKillerDamageToClient\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_ServerRankUpdate\"] = 52] = \"CS_UM_ServerRankUpdate\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_ItemPickup\"] = 53] = \"CS_UM_ItemPickup\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_ShowMenu\"] = 54] = \"CS_UM_ShowMenu\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_BarTime\"] = 55] = \"CS_UM_BarTime\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_AmmoDenied\"] = 56] = \"CS_UM_AmmoDenied\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_MarkAchievement\"] = 57] = \"CS_UM_MarkAchievement\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_MatchStatsUpdate\"] = 58] = \"CS_UM_MatchStatsUpdate\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_ItemDrop\"] = 59] = \"CS_UM_ItemDrop\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_GlowPropTurnOff\"] = 60] = \"CS_UM_GlowPropTurnOff\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_SendPlayerItemDrops\"] = 61] = \"CS_UM_SendPlayerItemDrops\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_RoundBackupFilenames\"] = 62] = \"CS_UM_RoundBackupFilenames\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_SendPlayerItemFound\"] = 63] = \"CS_UM_SendPlayerItemFound\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_ReportHit\"] = 64] = \"CS_UM_ReportHit\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_XpUpdate\"] = 65] = \"CS_UM_XpUpdate\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_QuestProgress\"] = 66] = \"CS_UM_QuestProgress\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_ScoreLeaderboardData\"] = 67] = \"CS_UM_ScoreLeaderboardData\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_PlayerDecalDigitalSignature\"] = 68] = \"CS_UM_PlayerDecalDigitalSignature\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_WeaponSound\"] = 69] = \"CS_UM_WeaponSound\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_UpdateScreenHealthBar\"] = 70] = \"CS_UM_UpdateScreenHealthBar\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_EntityOutlineHighlight\"] = 71] = \"CS_UM_EntityOutlineHighlight\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_SSUI\"] = 72] = \"CS_UM_SSUI\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_SurvivalStats\"] = 73] = \"CS_UM_SurvivalStats\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_DisconnectToLobby2\"] = 74] = \"CS_UM_DisconnectToLobby2\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_EndOfMatchAllPlayersData\"] = 75] = \"CS_UM_EndOfMatchAllPlayersData\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_RoundImpactScoreData\"] = 79] = \"CS_UM_RoundImpactScoreData\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_CurrentRoundOdds\"] = 80] = \"CS_UM_CurrentRoundOdds\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_DeepStats\"] = 81] = \"CS_UM_DeepStats\";\n    ECstrike15UserMessages[ECstrike15UserMessages[\"CS_UM_UtilMsg\"] = 82] = \"CS_UM_UtilMsg\";\n})(ECstrike15UserMessages = exports.ECstrike15UserMessages || (exports.ECstrike15UserMessages = {}));\nvar ECSUsrMsgDisconnectToLobbyAction;\n(function (ECSUsrMsgDisconnectToLobbyAction) {\n    ECSUsrMsgDisconnectToLobbyAction[ECSUsrMsgDisconnectToLobbyAction[\"k_ECSUsrMsg_DisconnectToLobby_Action_Default\"] = 0] = \"k_ECSUsrMsg_DisconnectToLobby_Action_Default\";\n    ECSUsrMsgDisconnectToLobbyAction[ECSUsrMsgDisconnectToLobbyAction[\"k_ECSUsrMsg_DisconnectToLobby_Action_GoQueue\"] = 1] = \"k_ECSUsrMsg_DisconnectToLobby_Action_GoQueue\";\n})(ECSUsrMsgDisconnectToLobbyAction = exports.ECSUsrMsgDisconnectToLobbyAction || (exports.ECSUsrMsgDisconnectToLobbyAction = {}));\nfunction createBaseCCSUsrMsgVGUIMenu() {\n    return { name: \"\", show: false, subkeys: [] };\n}\nexports.CCSUsrMsgVGUIMenu = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.name !== \"\") {\n            writer.uint32(10).string(message.name);\n        }\n        if (message.show === true) {\n            writer.uint32(16).bool(message.show);\n        }\n        for (const v of message.subkeys) {\n            exports.CCSUsrMsgVGUIMenu_Subkey.encode(v, writer.uint32(26).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgVGUIMenu();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.name = reader.string();\n                    break;\n                case 2:\n                    message.show = reader.bool();\n                    break;\n                case 3:\n                    message.subkeys.push(exports.CCSUsrMsgVGUIMenu_Subkey.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCCSUsrMsgVGUIMenu();\n        message.name = (_a = object.name) !== null && _a !== void 0 ? _a : \"\";\n        message.show = (_b = object.show) !== null && _b !== void 0 ? _b : false;\n        message.subkeys =\n            ((_c = object.subkeys) === null || _c === void 0 ? void 0 : _c.map(e => exports.CCSUsrMsgVGUIMenu_Subkey.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgVGUIMenu_Subkey() {\n    return { name: \"\", str: \"\" };\n}\nexports.CCSUsrMsgVGUIMenu_Subkey = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.name !== \"\") {\n            writer.uint32(10).string(message.name);\n        }\n        if (message.str !== \"\") {\n            writer.uint32(18).string(message.str);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgVGUIMenu_Subkey();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.name = reader.string();\n                    break;\n                case 2:\n                    message.str = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCCSUsrMsgVGUIMenu_Subkey();\n        message.name = (_a = object.name) !== null && _a !== void 0 ? _a : \"\";\n        message.str = (_b = object.str) !== null && _b !== void 0 ? _b : \"\";\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgGeiger() {\n    return { range: 0 };\n}\nexports.CCSUsrMsgGeiger = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.range !== 0) {\n            writer.uint32(8).int32(message.range);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgGeiger();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.range = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgGeiger();\n        message.range = (_a = object.range) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgTrain() {\n    return { train: 0 };\n}\nexports.CCSUsrMsgTrain = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.train !== 0) {\n            writer.uint32(8).int32(message.train);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgTrain();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.train = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgTrain();\n        message.train = (_a = object.train) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgHudText() {\n    return { text: \"\" };\n}\nexports.CCSUsrMsgHudText = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.text !== \"\") {\n            writer.uint32(10).string(message.text);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgHudText();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.text = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgHudText();\n        message.text = (_a = object.text) !== null && _a !== void 0 ? _a : \"\";\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgSayText() {\n    return { entIdx: 0, text: \"\", chat: false, textallchat: false };\n}\nexports.CCSUsrMsgSayText = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.entIdx !== 0) {\n            writer.uint32(8).int32(message.entIdx);\n        }\n        if (message.text !== \"\") {\n            writer.uint32(18).string(message.text);\n        }\n        if (message.chat === true) {\n            writer.uint32(24).bool(message.chat);\n        }\n        if (message.textallchat === true) {\n            writer.uint32(32).bool(message.textallchat);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgSayText();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.entIdx = reader.int32();\n                    break;\n                case 2:\n                    message.text = reader.string();\n                    break;\n                case 3:\n                    message.chat = reader.bool();\n                    break;\n                case 4:\n                    message.textallchat = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCSUsrMsgSayText();\n        message.entIdx = (_a = object.entIdx) !== null && _a !== void 0 ? _a : 0;\n        message.text = (_b = object.text) !== null && _b !== void 0 ? _b : \"\";\n        message.chat = (_c = object.chat) !== null && _c !== void 0 ? _c : false;\n        message.textallchat = (_d = object.textallchat) !== null && _d !== void 0 ? _d : false;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgSayText2() {\n    return {\n        entIdx: 0,\n        chat: false,\n        msgName: \"\",\n        params: [],\n        textallchat: false\n    };\n}\nexports.CCSUsrMsgSayText2 = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.entIdx !== 0) {\n            writer.uint32(8).int32(message.entIdx);\n        }\n        if (message.chat === true) {\n            writer.uint32(16).bool(message.chat);\n        }\n        if (message.msgName !== \"\") {\n            writer.uint32(26).string(message.msgName);\n        }\n        for (const v of message.params) {\n            writer.uint32(34).string(v);\n        }\n        if (message.textallchat === true) {\n            writer.uint32(40).bool(message.textallchat);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgSayText2();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.entIdx = reader.int32();\n                    break;\n                case 2:\n                    message.chat = reader.bool();\n                    break;\n                case 3:\n                    message.msgName = reader.string();\n                    break;\n                case 4:\n                    message.params.push(reader.string());\n                    break;\n                case 5:\n                    message.textallchat = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseCCSUsrMsgSayText2();\n        message.entIdx = (_a = object.entIdx) !== null && _a !== void 0 ? _a : 0;\n        message.chat = (_b = object.chat) !== null && _b !== void 0 ? _b : false;\n        message.msgName = (_c = object.msgName) !== null && _c !== void 0 ? _c : \"\";\n        message.params = ((_d = object.params) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];\n        message.textallchat = (_e = object.textallchat) !== null && _e !== void 0 ? _e : false;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgTextMsg() {\n    return { msgDst: 0, params: [] };\n}\nexports.CCSUsrMsgTextMsg = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.msgDst !== 0) {\n            writer.uint32(8).int32(message.msgDst);\n        }\n        for (const v of message.params) {\n            writer.uint32(26).string(v);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgTextMsg();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.msgDst = reader.int32();\n                    break;\n                case 3:\n                    message.params.push(reader.string());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCCSUsrMsgTextMsg();\n        message.msgDst = (_a = object.msgDst) !== null && _a !== void 0 ? _a : 0;\n        message.params = ((_b = object.params) === null || _b === void 0 ? void 0 : _b.map(e => e)) || [];\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgHudMsg() {\n    return {\n        channel: 0,\n        pos: undefined,\n        clr1: undefined,\n        clr2: undefined,\n        effect: 0,\n        fadeInTime: 0,\n        fadeOutTime: 0,\n        holdTime: 0,\n        fxTime: 0,\n        text: \"\"\n    };\n}\nexports.CCSUsrMsgHudMsg = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.channel !== 0) {\n            writer.uint32(8).int32(message.channel);\n        }\n        if (message.pos !== undefined) {\n            netmessages_1.CMsgVector2D.encode(message.pos, writer.uint32(18).fork()).ldelim();\n        }\n        if (message.clr1 !== undefined) {\n            netmessages_1.CMsgRGBA.encode(message.clr1, writer.uint32(26).fork()).ldelim();\n        }\n        if (message.clr2 !== undefined) {\n            netmessages_1.CMsgRGBA.encode(message.clr2, writer.uint32(34).fork()).ldelim();\n        }\n        if (message.effect !== 0) {\n            writer.uint32(40).int32(message.effect);\n        }\n        if (message.fadeInTime !== 0) {\n            writer.uint32(53).float(message.fadeInTime);\n        }\n        if (message.fadeOutTime !== 0) {\n            writer.uint32(61).float(message.fadeOutTime);\n        }\n        if (message.holdTime !== 0) {\n            writer.uint32(77).float(message.holdTime);\n        }\n        if (message.fxTime !== 0) {\n            writer.uint32(85).float(message.fxTime);\n        }\n        if (message.text !== \"\") {\n            writer.uint32(90).string(message.text);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgHudMsg();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.channel = reader.int32();\n                    break;\n                case 2:\n                    message.pos = netmessages_1.CMsgVector2D.decode(reader, reader.uint32());\n                    break;\n                case 3:\n                    message.clr1 = netmessages_1.CMsgRGBA.decode(reader, reader.uint32());\n                    break;\n                case 4:\n                    message.clr2 = netmessages_1.CMsgRGBA.decode(reader, reader.uint32());\n                    break;\n                case 5:\n                    message.effect = reader.int32();\n                    break;\n                case 6:\n                    message.fadeInTime = reader.float();\n                    break;\n                case 7:\n                    message.fadeOutTime = reader.float();\n                    break;\n                case 9:\n                    message.holdTime = reader.float();\n                    break;\n                case 10:\n                    message.fxTime = reader.float();\n                    break;\n                case 11:\n                    message.text = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g;\n        const message = createBaseCCSUsrMsgHudMsg();\n        message.channel = (_a = object.channel) !== null && _a !== void 0 ? _a : 0;\n        message.pos =\n            object.pos !== undefined && object.pos !== null\n                ? netmessages_1.CMsgVector2D.fromPartial(object.pos)\n                : undefined;\n        message.clr1 =\n            object.clr1 !== undefined && object.clr1 !== null\n                ? netmessages_1.CMsgRGBA.fromPartial(object.clr1)\n                : undefined;\n        message.clr2 =\n            object.clr2 !== undefined && object.clr2 !== null\n                ? netmessages_1.CMsgRGBA.fromPartial(object.clr2)\n                : undefined;\n        message.effect = (_b = object.effect) !== null && _b !== void 0 ? _b : 0;\n        message.fadeInTime = (_c = object.fadeInTime) !== null && _c !== void 0 ? _c : 0;\n        message.fadeOutTime = (_d = object.fadeOutTime) !== null && _d !== void 0 ? _d : 0;\n        message.holdTime = (_e = object.holdTime) !== null && _e !== void 0 ? _e : 0;\n        message.fxTime = (_f = object.fxTime) !== null && _f !== void 0 ? _f : 0;\n        message.text = (_g = object.text) !== null && _g !== void 0 ? _g : \"\";\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgShake() {\n    return { command: 0, localAmplitude: 0, frequency: 0, duration: 0 };\n}\nexports.CCSUsrMsgShake = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.command !== 0) {\n            writer.uint32(8).int32(message.command);\n        }\n        if (message.localAmplitude !== 0) {\n            writer.uint32(21).float(message.localAmplitude);\n        }\n        if (message.frequency !== 0) {\n            writer.uint32(29).float(message.frequency);\n        }\n        if (message.duration !== 0) {\n            writer.uint32(37).float(message.duration);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgShake();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.command = reader.int32();\n                    break;\n                case 2:\n                    message.localAmplitude = reader.float();\n                    break;\n                case 3:\n                    message.frequency = reader.float();\n                    break;\n                case 4:\n                    message.duration = reader.float();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCSUsrMsgShake();\n        message.command = (_a = object.command) !== null && _a !== void 0 ? _a : 0;\n        message.localAmplitude = (_b = object.localAmplitude) !== null && _b !== void 0 ? _b : 0;\n        message.frequency = (_c = object.frequency) !== null && _c !== void 0 ? _c : 0;\n        message.duration = (_d = object.duration) !== null && _d !== void 0 ? _d : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgFade() {\n    return { duration: 0, holdTime: 0, flags: 0, clr: undefined };\n}\nexports.CCSUsrMsgFade = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.duration !== 0) {\n            writer.uint32(8).int32(message.duration);\n        }\n        if (message.holdTime !== 0) {\n            writer.uint32(16).int32(message.holdTime);\n        }\n        if (message.flags !== 0) {\n            writer.uint32(24).int32(message.flags);\n        }\n        if (message.clr !== undefined) {\n            netmessages_1.CMsgRGBA.encode(message.clr, writer.uint32(34).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgFade();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.duration = reader.int32();\n                    break;\n                case 2:\n                    message.holdTime = reader.int32();\n                    break;\n                case 3:\n                    message.flags = reader.int32();\n                    break;\n                case 4:\n                    message.clr = netmessages_1.CMsgRGBA.decode(reader, reader.uint32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCCSUsrMsgFade();\n        message.duration = (_a = object.duration) !== null && _a !== void 0 ? _a : 0;\n        message.holdTime = (_b = object.holdTime) !== null && _b !== void 0 ? _b : 0;\n        message.flags = (_c = object.flags) !== null && _c !== void 0 ? _c : 0;\n        message.clr =\n            object.clr !== undefined && object.clr !== null\n                ? netmessages_1.CMsgRGBA.fromPartial(object.clr)\n                : undefined;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgRumble() {\n    return { index: 0, data: 0, flags: 0 };\n}\nexports.CCSUsrMsgRumble = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.index !== 0) {\n            writer.uint32(8).int32(message.index);\n        }\n        if (message.data !== 0) {\n            writer.uint32(16).int32(message.data);\n        }\n        if (message.flags !== 0) {\n            writer.uint32(24).int32(message.flags);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgRumble();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.index = reader.int32();\n                    break;\n                case 2:\n                    message.data = reader.int32();\n                    break;\n                case 3:\n                    message.flags = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCCSUsrMsgRumble();\n        message.index = (_a = object.index) !== null && _a !== void 0 ? _a : 0;\n        message.data = (_b = object.data) !== null && _b !== void 0 ? _b : 0;\n        message.flags = (_c = object.flags) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgCloseCaption() {\n    return { hash: 0, duration: 0, fromPlayer: false, cctoken: \"\" };\n}\nexports.CCSUsrMsgCloseCaption = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.hash !== 0) {\n            writer.uint32(8).uint32(message.hash);\n        }\n        if (message.duration !== 0) {\n            writer.uint32(16).int32(message.duration);\n        }\n        if (message.fromPlayer === true) {\n            writer.uint32(24).bool(message.fromPlayer);\n        }\n        if (message.cctoken !== \"\") {\n            writer.uint32(34).string(message.cctoken);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgCloseCaption();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.hash = reader.uint32();\n                    break;\n                case 2:\n                    message.duration = reader.int32();\n                    break;\n                case 3:\n                    message.fromPlayer = reader.bool();\n                    break;\n                case 4:\n                    message.cctoken = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCSUsrMsgCloseCaption();\n        message.hash = (_a = object.hash) !== null && _a !== void 0 ? _a : 0;\n        message.duration = (_b = object.duration) !== null && _b !== void 0 ? _b : 0;\n        message.fromPlayer = (_c = object.fromPlayer) !== null && _c !== void 0 ? _c : false;\n        message.cctoken = (_d = object.cctoken) !== null && _d !== void 0 ? _d : \"\";\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgCloseCaptionDirect() {\n    return { hash: 0, duration: 0, fromPlayer: false };\n}\nexports.CCSUsrMsgCloseCaptionDirect = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.hash !== 0) {\n            writer.uint32(8).uint32(message.hash);\n        }\n        if (message.duration !== 0) {\n            writer.uint32(16).int32(message.duration);\n        }\n        if (message.fromPlayer === true) {\n            writer.uint32(24).bool(message.fromPlayer);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgCloseCaptionDirect();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.hash = reader.uint32();\n                    break;\n                case 2:\n                    message.duration = reader.int32();\n                    break;\n                case 3:\n                    message.fromPlayer = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCCSUsrMsgCloseCaptionDirect();\n        message.hash = (_a = object.hash) !== null && _a !== void 0 ? _a : 0;\n        message.duration = (_b = object.duration) !== null && _b !== void 0 ? _b : 0;\n        message.fromPlayer = (_c = object.fromPlayer) !== null && _c !== void 0 ? _c : false;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgSendAudio() {\n    return { radioSound: \"\" };\n}\nexports.CCSUsrMsgSendAudio = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.radioSound !== \"\") {\n            writer.uint32(10).string(message.radioSound);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgSendAudio();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.radioSound = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgSendAudio();\n        message.radioSound = (_a = object.radioSound) !== null && _a !== void 0 ? _a : \"\";\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgRawAudio() {\n    return { pitch: 0, entidx: 0, duration: 0, voiceFilename: \"\" };\n}\nexports.CCSUsrMsgRawAudio = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.pitch !== 0) {\n            writer.uint32(8).int32(message.pitch);\n        }\n        if (message.entidx !== 0) {\n            writer.uint32(16).int32(message.entidx);\n        }\n        if (message.duration !== 0) {\n            writer.uint32(29).float(message.duration);\n        }\n        if (message.voiceFilename !== \"\") {\n            writer.uint32(34).string(message.voiceFilename);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgRawAudio();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.pitch = reader.int32();\n                    break;\n                case 2:\n                    message.entidx = reader.int32();\n                    break;\n                case 3:\n                    message.duration = reader.float();\n                    break;\n                case 4:\n                    message.voiceFilename = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCSUsrMsgRawAudio();\n        message.pitch = (_a = object.pitch) !== null && _a !== void 0 ? _a : 0;\n        message.entidx = (_b = object.entidx) !== null && _b !== void 0 ? _b : 0;\n        message.duration = (_c = object.duration) !== null && _c !== void 0 ? _c : 0;\n        message.voiceFilename = (_d = object.voiceFilename) !== null && _d !== void 0 ? _d : \"\";\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgVoiceMask() {\n    return { playerMasks: [], playerModEnable: false };\n}\nexports.CCSUsrMsgVoiceMask = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.playerMasks) {\n            exports.CCSUsrMsgVoiceMask_PlayerMask.encode(v, writer.uint32(10).fork()).ldelim();\n        }\n        if (message.playerModEnable === true) {\n            writer.uint32(16).bool(message.playerModEnable);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgVoiceMask();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.playerMasks.push(exports.CCSUsrMsgVoiceMask_PlayerMask.decode(reader, reader.uint32()));\n                    break;\n                case 2:\n                    message.playerModEnable = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCCSUsrMsgVoiceMask();\n        message.playerMasks =\n            ((_a = object.playerMasks) === null || _a === void 0 ? void 0 : _a.map(e => exports.CCSUsrMsgVoiceMask_PlayerMask.fromPartial(e))) || [];\n        message.playerModEnable = (_b = object.playerModEnable) !== null && _b !== void 0 ? _b : false;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgVoiceMask_PlayerMask() {\n    return { gameRulesMask: 0, banMasks: 0 };\n}\nexports.CCSUsrMsgVoiceMask_PlayerMask = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.gameRulesMask !== 0) {\n            writer.uint32(8).int32(message.gameRulesMask);\n        }\n        if (message.banMasks !== 0) {\n            writer.uint32(16).int32(message.banMasks);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgVoiceMask_PlayerMask();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.gameRulesMask = reader.int32();\n                    break;\n                case 2:\n                    message.banMasks = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCCSUsrMsgVoiceMask_PlayerMask();\n        message.gameRulesMask = (_a = object.gameRulesMask) !== null && _a !== void 0 ? _a : 0;\n        message.banMasks = (_b = object.banMasks) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgDamage() {\n    return { amount: 0, inflictorWorldPos: undefined, victimEntindex: 0 };\n}\nexports.CCSUsrMsgDamage = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.amount !== 0) {\n            writer.uint32(8).int32(message.amount);\n        }\n        if (message.inflictorWorldPos !== undefined) {\n            netmessages_1.CMsgVector.encode(message.inflictorWorldPos, writer.uint32(18).fork()).ldelim();\n        }\n        if (message.victimEntindex !== 0) {\n            writer.uint32(24).int32(message.victimEntindex);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgDamage();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.amount = reader.int32();\n                    break;\n                case 2:\n                    message.inflictorWorldPos = netmessages_1.CMsgVector.decode(reader, reader.uint32());\n                    break;\n                case 3:\n                    message.victimEntindex = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCCSUsrMsgDamage();\n        message.amount = (_a = object.amount) !== null && _a !== void 0 ? _a : 0;\n        message.inflictorWorldPos =\n            object.inflictorWorldPos !== undefined &&\n                object.inflictorWorldPos !== null\n                ? netmessages_1.CMsgVector.fromPartial(object.inflictorWorldPos)\n                : undefined;\n        message.victimEntindex = (_b = object.victimEntindex) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgRadioText() {\n    return { msgDst: 0, client: 0, msgName: \"\", params: [] };\n}\nexports.CCSUsrMsgRadioText = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.msgDst !== 0) {\n            writer.uint32(8).int32(message.msgDst);\n        }\n        if (message.client !== 0) {\n            writer.uint32(16).int32(message.client);\n        }\n        if (message.msgName !== \"\") {\n            writer.uint32(26).string(message.msgName);\n        }\n        for (const v of message.params) {\n            writer.uint32(34).string(v);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgRadioText();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.msgDst = reader.int32();\n                    break;\n                case 2:\n                    message.client = reader.int32();\n                    break;\n                case 3:\n                    message.msgName = reader.string();\n                    break;\n                case 4:\n                    message.params.push(reader.string());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCSUsrMsgRadioText();\n        message.msgDst = (_a = object.msgDst) !== null && _a !== void 0 ? _a : 0;\n        message.client = (_b = object.client) !== null && _b !== void 0 ? _b : 0;\n        message.msgName = (_c = object.msgName) !== null && _c !== void 0 ? _c : \"\";\n        message.params = ((_d = object.params) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgHintText() {\n    return { text: \"\" };\n}\nexports.CCSUsrMsgHintText = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.text !== \"\") {\n            writer.uint32(10).string(message.text);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgHintText();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.text = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgHintText();\n        message.text = (_a = object.text) !== null && _a !== void 0 ? _a : \"\";\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgKeyHintText() {\n    return { hints: [] };\n}\nexports.CCSUsrMsgKeyHintText = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.hints) {\n            writer.uint32(10).string(v);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgKeyHintText();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.hints.push(reader.string());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgKeyHintText();\n        message.hints = ((_a = object.hints) === null || _a === void 0 ? void 0 : _a.map(e => e)) || [];\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgProcessSpottedEntityUpdate() {\n    return { newUpdate: false, entityUpdates: [] };\n}\nexports.CCSUsrMsgProcessSpottedEntityUpdate = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.newUpdate === true) {\n            writer.uint32(8).bool(message.newUpdate);\n        }\n        for (const v of message.entityUpdates) {\n            exports.CCSUsrMsgProcessSpottedEntityUpdate_SpottedEntityUpdate.encode(v, writer.uint32(18).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgProcessSpottedEntityUpdate();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.newUpdate = reader.bool();\n                    break;\n                case 2:\n                    message.entityUpdates.push(exports.CCSUsrMsgProcessSpottedEntityUpdate_SpottedEntityUpdate.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCCSUsrMsgProcessSpottedEntityUpdate();\n        message.newUpdate = (_a = object.newUpdate) !== null && _a !== void 0 ? _a : false;\n        message.entityUpdates =\n            ((_b = object.entityUpdates) === null || _b === void 0 ? void 0 : _b.map(e => exports.CCSUsrMsgProcessSpottedEntityUpdate_SpottedEntityUpdate.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgProcessSpottedEntityUpdate_SpottedEntityUpdate() {\n    return {\n        entityIdx: 0,\n        classId: 0,\n        originX: 0,\n        originY: 0,\n        originZ: 0,\n        angleY: 0,\n        defuser: false,\n        playerHasDefuser: false,\n        playerHasC4: false\n    };\n}\nexports.CCSUsrMsgProcessSpottedEntityUpdate_SpottedEntityUpdate = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.entityIdx !== 0) {\n            writer.uint32(8).int32(message.entityIdx);\n        }\n        if (message.classId !== 0) {\n            writer.uint32(16).int32(message.classId);\n        }\n        if (message.originX !== 0) {\n            writer.uint32(24).int32(message.originX);\n        }\n        if (message.originY !== 0) {\n            writer.uint32(32).int32(message.originY);\n        }\n        if (message.originZ !== 0) {\n            writer.uint32(40).int32(message.originZ);\n        }\n        if (message.angleY !== 0) {\n            writer.uint32(48).int32(message.angleY);\n        }\n        if (message.defuser === true) {\n            writer.uint32(56).bool(message.defuser);\n        }\n        if (message.playerHasDefuser === true) {\n            writer.uint32(64).bool(message.playerHasDefuser);\n        }\n        if (message.playerHasC4 === true) {\n            writer.uint32(72).bool(message.playerHasC4);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgProcessSpottedEntityUpdate_SpottedEntityUpdate();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.entityIdx = reader.int32();\n                    break;\n                case 2:\n                    message.classId = reader.int32();\n                    break;\n                case 3:\n                    message.originX = reader.int32();\n                    break;\n                case 4:\n                    message.originY = reader.int32();\n                    break;\n                case 5:\n                    message.originZ = reader.int32();\n                    break;\n                case 6:\n                    message.angleY = reader.int32();\n                    break;\n                case 7:\n                    message.defuser = reader.bool();\n                    break;\n                case 8:\n                    message.playerHasDefuser = reader.bool();\n                    break;\n                case 9:\n                    message.playerHasC4 = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j;\n        const message = createBaseCCSUsrMsgProcessSpottedEntityUpdate_SpottedEntityUpdate();\n        message.entityIdx = (_a = object.entityIdx) !== null && _a !== void 0 ? _a : 0;\n        message.classId = (_b = object.classId) !== null && _b !== void 0 ? _b : 0;\n        message.originX = (_c = object.originX) !== null && _c !== void 0 ? _c : 0;\n        message.originY = (_d = object.originY) !== null && _d !== void 0 ? _d : 0;\n        message.originZ = (_e = object.originZ) !== null && _e !== void 0 ? _e : 0;\n        message.angleY = (_f = object.angleY) !== null && _f !== void 0 ? _f : 0;\n        message.defuser = (_g = object.defuser) !== null && _g !== void 0 ? _g : false;\n        message.playerHasDefuser = (_h = object.playerHasDefuser) !== null && _h !== void 0 ? _h : false;\n        message.playerHasC4 = (_j = object.playerHasC4) !== null && _j !== void 0 ? _j : false;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgSendPlayerItemDrops() {\n    return { entityUpdates: [] };\n}\nexports.CCSUsrMsgSendPlayerItemDrops = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.entityUpdates) {\n            cstrike15_gcmessages_1.CEconItemPreviewDataBlock.encode(v, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgSendPlayerItemDrops();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.entityUpdates.push(cstrike15_gcmessages_1.CEconItemPreviewDataBlock.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgSendPlayerItemDrops();\n        message.entityUpdates =\n            ((_a = object.entityUpdates) === null || _a === void 0 ? void 0 : _a.map(e => cstrike15_gcmessages_1.CEconItemPreviewDataBlock.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgSendPlayerItemFound() {\n    return { iteminfo: undefined, entindex: 0 };\n}\nexports.CCSUsrMsgSendPlayerItemFound = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.iteminfo !== undefined) {\n            cstrike15_gcmessages_1.CEconItemPreviewDataBlock.encode(message.iteminfo, writer.uint32(10).fork()).ldelim();\n        }\n        if (message.entindex !== 0) {\n            writer.uint32(16).int32(message.entindex);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgSendPlayerItemFound();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.iteminfo = cstrike15_gcmessages_1.CEconItemPreviewDataBlock.decode(reader, reader.uint32());\n                    break;\n                case 2:\n                    message.entindex = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgSendPlayerItemFound();\n        message.iteminfo =\n            object.iteminfo !== undefined && object.iteminfo !== null\n                ? cstrike15_gcmessages_1.CEconItemPreviewDataBlock.fromPartial(object.iteminfo)\n                : undefined;\n        message.entindex = (_a = object.entindex) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgReloadEffect() {\n    return { entidx: 0, actanim: 0, originX: 0, originY: 0, originZ: 0 };\n}\nexports.CCSUsrMsgReloadEffect = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.entidx !== 0) {\n            writer.uint32(8).int32(message.entidx);\n        }\n        if (message.actanim !== 0) {\n            writer.uint32(16).int32(message.actanim);\n        }\n        if (message.originX !== 0) {\n            writer.uint32(29).float(message.originX);\n        }\n        if (message.originY !== 0) {\n            writer.uint32(37).float(message.originY);\n        }\n        if (message.originZ !== 0) {\n            writer.uint32(45).float(message.originZ);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgReloadEffect();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.entidx = reader.int32();\n                    break;\n                case 2:\n                    message.actanim = reader.int32();\n                    break;\n                case 3:\n                    message.originX = reader.float();\n                    break;\n                case 4:\n                    message.originY = reader.float();\n                    break;\n                case 5:\n                    message.originZ = reader.float();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseCCSUsrMsgReloadEffect();\n        message.entidx = (_a = object.entidx) !== null && _a !== void 0 ? _a : 0;\n        message.actanim = (_b = object.actanim) !== null && _b !== void 0 ? _b : 0;\n        message.originX = (_c = object.originX) !== null && _c !== void 0 ? _c : 0;\n        message.originY = (_d = object.originY) !== null && _d !== void 0 ? _d : 0;\n        message.originZ = (_e = object.originZ) !== null && _e !== void 0 ? _e : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgWeaponSound() {\n    return {\n        entidx: 0,\n        originX: 0,\n        originY: 0,\n        originZ: 0,\n        sound: \"\",\n        timestamp: 0\n    };\n}\nexports.CCSUsrMsgWeaponSound = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.entidx !== 0) {\n            writer.uint32(8).int32(message.entidx);\n        }\n        if (message.originX !== 0) {\n            writer.uint32(21).float(message.originX);\n        }\n        if (message.originY !== 0) {\n            writer.uint32(29).float(message.originY);\n        }\n        if (message.originZ !== 0) {\n            writer.uint32(37).float(message.originZ);\n        }\n        if (message.sound !== \"\") {\n            writer.uint32(42).string(message.sound);\n        }\n        if (message.timestamp !== 0) {\n            writer.uint32(53).float(message.timestamp);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgWeaponSound();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.entidx = reader.int32();\n                    break;\n                case 2:\n                    message.originX = reader.float();\n                    break;\n                case 3:\n                    message.originY = reader.float();\n                    break;\n                case 4:\n                    message.originZ = reader.float();\n                    break;\n                case 5:\n                    message.sound = reader.string();\n                    break;\n                case 6:\n                    message.timestamp = reader.float();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f;\n        const message = createBaseCCSUsrMsgWeaponSound();\n        message.entidx = (_a = object.entidx) !== null && _a !== void 0 ? _a : 0;\n        message.originX = (_b = object.originX) !== null && _b !== void 0 ? _b : 0;\n        message.originY = (_c = object.originY) !== null && _c !== void 0 ? _c : 0;\n        message.originZ = (_d = object.originZ) !== null && _d !== void 0 ? _d : 0;\n        message.sound = (_e = object.sound) !== null && _e !== void 0 ? _e : \"\";\n        message.timestamp = (_f = object.timestamp) !== null && _f !== void 0 ? _f : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgUpdateScreenHealthBar() {\n    return { entidx: 0, healthratioOld: 0, healthratioNew: 0, style: 0 };\n}\nexports.CCSUsrMsgUpdateScreenHealthBar = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.entidx !== 0) {\n            writer.uint32(8).int32(message.entidx);\n        }\n        if (message.healthratioOld !== 0) {\n            writer.uint32(21).float(message.healthratioOld);\n        }\n        if (message.healthratioNew !== 0) {\n            writer.uint32(29).float(message.healthratioNew);\n        }\n        if (message.style !== 0) {\n            writer.uint32(32).int32(message.style);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgUpdateScreenHealthBar();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.entidx = reader.int32();\n                    break;\n                case 2:\n                    message.healthratioOld = reader.float();\n                    break;\n                case 3:\n                    message.healthratioNew = reader.float();\n                    break;\n                case 4:\n                    message.style = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCSUsrMsgUpdateScreenHealthBar();\n        message.entidx = (_a = object.entidx) !== null && _a !== void 0 ? _a : 0;\n        message.healthratioOld = (_b = object.healthratioOld) !== null && _b !== void 0 ? _b : 0;\n        message.healthratioNew = (_c = object.healthratioNew) !== null && _c !== void 0 ? _c : 0;\n        message.style = (_d = object.style) !== null && _d !== void 0 ? _d : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgEntityOutlineHighlight() {\n    return { entidx: 0, removehighlight: false };\n}\nexports.CCSUsrMsgEntityOutlineHighlight = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.entidx !== 0) {\n            writer.uint32(8).int32(message.entidx);\n        }\n        if (message.removehighlight === true) {\n            writer.uint32(16).bool(message.removehighlight);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgEntityOutlineHighlight();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.entidx = reader.int32();\n                    break;\n                case 2:\n                    message.removehighlight = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCCSUsrMsgEntityOutlineHighlight();\n        message.entidx = (_a = object.entidx) !== null && _a !== void 0 ? _a : 0;\n        message.removehighlight = (_b = object.removehighlight) !== null && _b !== void 0 ? _b : false;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgAdjustMoney() {\n    return { amount: 0 };\n}\nexports.CCSUsrMsgAdjustMoney = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.amount !== 0) {\n            writer.uint32(8).int32(message.amount);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgAdjustMoney();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.amount = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgAdjustMoney();\n        message.amount = (_a = object.amount) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgReportHit() {\n    return { posX: 0, posY: 0, timestamp: 0, posZ: 0 };\n}\nexports.CCSUsrMsgReportHit = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.posX !== 0) {\n            writer.uint32(13).float(message.posX);\n        }\n        if (message.posY !== 0) {\n            writer.uint32(21).float(message.posY);\n        }\n        if (message.timestamp !== 0) {\n            writer.uint32(37).float(message.timestamp);\n        }\n        if (message.posZ !== 0) {\n            writer.uint32(29).float(message.posZ);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgReportHit();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.posX = reader.float();\n                    break;\n                case 2:\n                    message.posY = reader.float();\n                    break;\n                case 4:\n                    message.timestamp = reader.float();\n                    break;\n                case 3:\n                    message.posZ = reader.float();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCSUsrMsgReportHit();\n        message.posX = (_a = object.posX) !== null && _a !== void 0 ? _a : 0;\n        message.posY = (_b = object.posY) !== null && _b !== void 0 ? _b : 0;\n        message.timestamp = (_c = object.timestamp) !== null && _c !== void 0 ? _c : 0;\n        message.posZ = (_d = object.posZ) !== null && _d !== void 0 ? _d : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgKillCam() {\n    return { obsMode: 0, firstTarget: 0, secondTarget: 0 };\n}\nexports.CCSUsrMsgKillCam = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.obsMode !== 0) {\n            writer.uint32(8).int32(message.obsMode);\n        }\n        if (message.firstTarget !== 0) {\n            writer.uint32(16).int32(message.firstTarget);\n        }\n        if (message.secondTarget !== 0) {\n            writer.uint32(24).int32(message.secondTarget);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgKillCam();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.obsMode = reader.int32();\n                    break;\n                case 2:\n                    message.firstTarget = reader.int32();\n                    break;\n                case 3:\n                    message.secondTarget = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCCSUsrMsgKillCam();\n        message.obsMode = (_a = object.obsMode) !== null && _a !== void 0 ? _a : 0;\n        message.firstTarget = (_b = object.firstTarget) !== null && _b !== void 0 ? _b : 0;\n        message.secondTarget = (_c = object.secondTarget) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgDesiredTimescale() {\n    return {\n        desiredTimescale: 0,\n        durationRealtimeSec: 0,\n        interpolatorType: 0,\n        startBlendTime: 0\n    };\n}\nexports.CCSUsrMsgDesiredTimescale = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.desiredTimescale !== 0) {\n            writer.uint32(13).float(message.desiredTimescale);\n        }\n        if (message.durationRealtimeSec !== 0) {\n            writer.uint32(21).float(message.durationRealtimeSec);\n        }\n        if (message.interpolatorType !== 0) {\n            writer.uint32(24).int32(message.interpolatorType);\n        }\n        if (message.startBlendTime !== 0) {\n            writer.uint32(37).float(message.startBlendTime);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgDesiredTimescale();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.desiredTimescale = reader.float();\n                    break;\n                case 2:\n                    message.durationRealtimeSec = reader.float();\n                    break;\n                case 3:\n                    message.interpolatorType = reader.int32();\n                    break;\n                case 4:\n                    message.startBlendTime = reader.float();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCSUsrMsgDesiredTimescale();\n        message.desiredTimescale = (_a = object.desiredTimescale) !== null && _a !== void 0 ? _a : 0;\n        message.durationRealtimeSec = (_b = object.durationRealtimeSec) !== null && _b !== void 0 ? _b : 0;\n        message.interpolatorType = (_c = object.interpolatorType) !== null && _c !== void 0 ? _c : 0;\n        message.startBlendTime = (_d = object.startBlendTime) !== null && _d !== void 0 ? _d : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgCurrentTimescale() {\n    return { curTimescale: 0 };\n}\nexports.CCSUsrMsgCurrentTimescale = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.curTimescale !== 0) {\n            writer.uint32(13).float(message.curTimescale);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgCurrentTimescale();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.curTimescale = reader.float();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgCurrentTimescale();\n        message.curTimescale = (_a = object.curTimescale) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgAchievementEvent() {\n    return { achievement: 0, count: 0, userId: 0 };\n}\nexports.CCSUsrMsgAchievementEvent = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.achievement !== 0) {\n            writer.uint32(8).int32(message.achievement);\n        }\n        if (message.count !== 0) {\n            writer.uint32(16).int32(message.count);\n        }\n        if (message.userId !== 0) {\n            writer.uint32(24).int32(message.userId);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgAchievementEvent();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.achievement = reader.int32();\n                    break;\n                case 2:\n                    message.count = reader.int32();\n                    break;\n                case 3:\n                    message.userId = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCCSUsrMsgAchievementEvent();\n        message.achievement = (_a = object.achievement) !== null && _a !== void 0 ? _a : 0;\n        message.count = (_b = object.count) !== null && _b !== void 0 ? _b : 0;\n        message.userId = (_c = object.userId) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgMatchEndConditions() {\n    return { fraglimit: 0, mpMaxrounds: 0, mpWinlimit: 0, mpTimelimit: 0 };\n}\nexports.CCSUsrMsgMatchEndConditions = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.fraglimit !== 0) {\n            writer.uint32(8).int32(message.fraglimit);\n        }\n        if (message.mpMaxrounds !== 0) {\n            writer.uint32(16).int32(message.mpMaxrounds);\n        }\n        if (message.mpWinlimit !== 0) {\n            writer.uint32(24).int32(message.mpWinlimit);\n        }\n        if (message.mpTimelimit !== 0) {\n            writer.uint32(32).int32(message.mpTimelimit);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgMatchEndConditions();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.fraglimit = reader.int32();\n                    break;\n                case 2:\n                    message.mpMaxrounds = reader.int32();\n                    break;\n                case 3:\n                    message.mpWinlimit = reader.int32();\n                    break;\n                case 4:\n                    message.mpTimelimit = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCSUsrMsgMatchEndConditions();\n        message.fraglimit = (_a = object.fraglimit) !== null && _a !== void 0 ? _a : 0;\n        message.mpMaxrounds = (_b = object.mpMaxrounds) !== null && _b !== void 0 ? _b : 0;\n        message.mpWinlimit = (_c = object.mpWinlimit) !== null && _c !== void 0 ? _c : 0;\n        message.mpTimelimit = (_d = object.mpTimelimit) !== null && _d !== void 0 ? _d : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgPlayerStatsUpdate() {\n    return { version: 0, stats: [], userId: 0, crc: 0 };\n}\nexports.CCSUsrMsgPlayerStatsUpdate = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.version !== 0) {\n            writer.uint32(8).int32(message.version);\n        }\n        for (const v of message.stats) {\n            exports.CCSUsrMsgPlayerStatsUpdate_Stat.encode(v, writer.uint32(34).fork()).ldelim();\n        }\n        if (message.userId !== 0) {\n            writer.uint32(40).int32(message.userId);\n        }\n        if (message.crc !== 0) {\n            writer.uint32(48).int32(message.crc);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgPlayerStatsUpdate();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.version = reader.int32();\n                    break;\n                case 4:\n                    message.stats.push(exports.CCSUsrMsgPlayerStatsUpdate_Stat.decode(reader, reader.uint32()));\n                    break;\n                case 5:\n                    message.userId = reader.int32();\n                    break;\n                case 6:\n                    message.crc = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCSUsrMsgPlayerStatsUpdate();\n        message.version = (_a = object.version) !== null && _a !== void 0 ? _a : 0;\n        message.stats =\n            ((_b = object.stats) === null || _b === void 0 ? void 0 : _b.map(e => exports.CCSUsrMsgPlayerStatsUpdate_Stat.fromPartial(e))) ||\n                [];\n        message.userId = (_c = object.userId) !== null && _c !== void 0 ? _c : 0;\n        message.crc = (_d = object.crc) !== null && _d !== void 0 ? _d : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgPlayerStatsUpdate_Stat() {\n    return { idx: 0, delta: 0 };\n}\nexports.CCSUsrMsgPlayerStatsUpdate_Stat = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.idx !== 0) {\n            writer.uint32(8).int32(message.idx);\n        }\n        if (message.delta !== 0) {\n            writer.uint32(16).int32(message.delta);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgPlayerStatsUpdate_Stat();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.idx = reader.int32();\n                    break;\n                case 2:\n                    message.delta = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCCSUsrMsgPlayerStatsUpdate_Stat();\n        message.idx = (_a = object.idx) !== null && _a !== void 0 ? _a : 0;\n        message.delta = (_b = object.delta) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgDisplayInventory() {\n    return { display: false, userId: 0 };\n}\nexports.CCSUsrMsgDisplayInventory = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.display === true) {\n            writer.uint32(8).bool(message.display);\n        }\n        if (message.userId !== 0) {\n            writer.uint32(16).int32(message.userId);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgDisplayInventory();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.display = reader.bool();\n                    break;\n                case 2:\n                    message.userId = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCCSUsrMsgDisplayInventory();\n        message.display = (_a = object.display) !== null && _a !== void 0 ? _a : false;\n        message.userId = (_b = object.userId) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgQuestProgress() {\n    return { questId: 0, normalPoints: 0, bonusPoints: 0, isEventQuest: false };\n}\nexports.CCSUsrMsgQuestProgress = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.questId !== 0) {\n            writer.uint32(8).uint32(message.questId);\n        }\n        if (message.normalPoints !== 0) {\n            writer.uint32(16).uint32(message.normalPoints);\n        }\n        if (message.bonusPoints !== 0) {\n            writer.uint32(24).uint32(message.bonusPoints);\n        }\n        if (message.isEventQuest === true) {\n            writer.uint32(32).bool(message.isEventQuest);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgQuestProgress();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.questId = reader.uint32();\n                    break;\n                case 2:\n                    message.normalPoints = reader.uint32();\n                    break;\n                case 3:\n                    message.bonusPoints = reader.uint32();\n                    break;\n                case 4:\n                    message.isEventQuest = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCSUsrMsgQuestProgress();\n        message.questId = (_a = object.questId) !== null && _a !== void 0 ? _a : 0;\n        message.normalPoints = (_b = object.normalPoints) !== null && _b !== void 0 ? _b : 0;\n        message.bonusPoints = (_c = object.bonusPoints) !== null && _c !== void 0 ? _c : 0;\n        message.isEventQuest = (_d = object.isEventQuest) !== null && _d !== void 0 ? _d : false;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgScoreLeaderboardData() {\n    return { data: undefined };\n}\nexports.CCSUsrMsgScoreLeaderboardData = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.data !== undefined) {\n            cstrike15_gcmessages_1.ScoreLeaderboardData.encode(message.data, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgScoreLeaderboardData();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.data = cstrike15_gcmessages_1.ScoreLeaderboardData.decode(reader, reader.uint32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        const message = createBaseCCSUsrMsgScoreLeaderboardData();\n        message.data =\n            object.data !== undefined && object.data !== null\n                ? cstrike15_gcmessages_1.ScoreLeaderboardData.fromPartial(object.data)\n                : undefined;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgPlayerDecalDigitalSignature() {\n    return { data: undefined };\n}\nexports.CCSUsrMsgPlayerDecalDigitalSignature = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.data !== undefined) {\n            cstrike15_gcmessages_1.PlayerDecalDigitalSignature.encode(message.data, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgPlayerDecalDigitalSignature();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.data = cstrike15_gcmessages_1.PlayerDecalDigitalSignature.decode(reader, reader.uint32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        const message = createBaseCCSUsrMsgPlayerDecalDigitalSignature();\n        message.data =\n            object.data !== undefined && object.data !== null\n                ? cstrike15_gcmessages_1.PlayerDecalDigitalSignature.fromPartial(object.data)\n                : undefined;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgXRankGet() {\n    return { modeIdx: 0, controller: 0 };\n}\nexports.CCSUsrMsgXRankGet = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.modeIdx !== 0) {\n            writer.uint32(8).int32(message.modeIdx);\n        }\n        if (message.controller !== 0) {\n            writer.uint32(16).int32(message.controller);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgXRankGet();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.modeIdx = reader.int32();\n                    break;\n                case 2:\n                    message.controller = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCCSUsrMsgXRankGet();\n        message.modeIdx = (_a = object.modeIdx) !== null && _a !== void 0 ? _a : 0;\n        message.controller = (_b = object.controller) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgXRankUpd() {\n    return { modeIdx: 0, controller: 0, ranking: 0 };\n}\nexports.CCSUsrMsgXRankUpd = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.modeIdx !== 0) {\n            writer.uint32(8).int32(message.modeIdx);\n        }\n        if (message.controller !== 0) {\n            writer.uint32(16).int32(message.controller);\n        }\n        if (message.ranking !== 0) {\n            writer.uint32(24).int32(message.ranking);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgXRankUpd();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.modeIdx = reader.int32();\n                    break;\n                case 2:\n                    message.controller = reader.int32();\n                    break;\n                case 3:\n                    message.ranking = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCCSUsrMsgXRankUpd();\n        message.modeIdx = (_a = object.modeIdx) !== null && _a !== void 0 ? _a : 0;\n        message.controller = (_b = object.controller) !== null && _b !== void 0 ? _b : 0;\n        message.ranking = (_c = object.ranking) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgCallVoteFailed() {\n    return { reason: 0, time: 0 };\n}\nexports.CCSUsrMsgCallVoteFailed = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.reason !== 0) {\n            writer.uint32(8).int32(message.reason);\n        }\n        if (message.time !== 0) {\n            writer.uint32(16).int32(message.time);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgCallVoteFailed();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.reason = reader.int32();\n                    break;\n                case 2:\n                    message.time = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCCSUsrMsgCallVoteFailed();\n        message.reason = (_a = object.reason) !== null && _a !== void 0 ? _a : 0;\n        message.time = (_b = object.time) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgVoteStart() {\n    return {\n        team: 0,\n        entIdx: 0,\n        voteType: 0,\n        dispStr: \"\",\n        detailsStr: \"\",\n        otherTeamStr: \"\",\n        isYesNoVote: false,\n        entidxTarget: 0\n    };\n}\nexports.CCSUsrMsgVoteStart = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.team !== 0) {\n            writer.uint32(8).int32(message.team);\n        }\n        if (message.entIdx !== 0) {\n            writer.uint32(16).int32(message.entIdx);\n        }\n        if (message.voteType !== 0) {\n            writer.uint32(24).int32(message.voteType);\n        }\n        if (message.dispStr !== \"\") {\n            writer.uint32(34).string(message.dispStr);\n        }\n        if (message.detailsStr !== \"\") {\n            writer.uint32(42).string(message.detailsStr);\n        }\n        if (message.otherTeamStr !== \"\") {\n            writer.uint32(50).string(message.otherTeamStr);\n        }\n        if (message.isYesNoVote === true) {\n            writer.uint32(56).bool(message.isYesNoVote);\n        }\n        if (message.entidxTarget !== 0) {\n            writer.uint32(64).int32(message.entidxTarget);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgVoteStart();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.team = reader.int32();\n                    break;\n                case 2:\n                    message.entIdx = reader.int32();\n                    break;\n                case 3:\n                    message.voteType = reader.int32();\n                    break;\n                case 4:\n                    message.dispStr = reader.string();\n                    break;\n                case 5:\n                    message.detailsStr = reader.string();\n                    break;\n                case 6:\n                    message.otherTeamStr = reader.string();\n                    break;\n                case 7:\n                    message.isYesNoVote = reader.bool();\n                    break;\n                case 8:\n                    message.entidxTarget = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h;\n        const message = createBaseCCSUsrMsgVoteStart();\n        message.team = (_a = object.team) !== null && _a !== void 0 ? _a : 0;\n        message.entIdx = (_b = object.entIdx) !== null && _b !== void 0 ? _b : 0;\n        message.voteType = (_c = object.voteType) !== null && _c !== void 0 ? _c : 0;\n        message.dispStr = (_d = object.dispStr) !== null && _d !== void 0 ? _d : \"\";\n        message.detailsStr = (_e = object.detailsStr) !== null && _e !== void 0 ? _e : \"\";\n        message.otherTeamStr = (_f = object.otherTeamStr) !== null && _f !== void 0 ? _f : \"\";\n        message.isYesNoVote = (_g = object.isYesNoVote) !== null && _g !== void 0 ? _g : false;\n        message.entidxTarget = (_h = object.entidxTarget) !== null && _h !== void 0 ? _h : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgVotePass() {\n    return { team: 0, voteType: 0, dispStr: \"\", detailsStr: \"\" };\n}\nexports.CCSUsrMsgVotePass = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.team !== 0) {\n            writer.uint32(8).int32(message.team);\n        }\n        if (message.voteType !== 0) {\n            writer.uint32(16).int32(message.voteType);\n        }\n        if (message.dispStr !== \"\") {\n            writer.uint32(26).string(message.dispStr);\n        }\n        if (message.detailsStr !== \"\") {\n            writer.uint32(34).string(message.detailsStr);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgVotePass();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.team = reader.int32();\n                    break;\n                case 2:\n                    message.voteType = reader.int32();\n                    break;\n                case 3:\n                    message.dispStr = reader.string();\n                    break;\n                case 4:\n                    message.detailsStr = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCSUsrMsgVotePass();\n        message.team = (_a = object.team) !== null && _a !== void 0 ? _a : 0;\n        message.voteType = (_b = object.voteType) !== null && _b !== void 0 ? _b : 0;\n        message.dispStr = (_c = object.dispStr) !== null && _c !== void 0 ? _c : \"\";\n        message.detailsStr = (_d = object.detailsStr) !== null && _d !== void 0 ? _d : \"\";\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgVoteFailed() {\n    return { team: 0, reason: 0 };\n}\nexports.CCSUsrMsgVoteFailed = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.team !== 0) {\n            writer.uint32(8).int32(message.team);\n        }\n        if (message.reason !== 0) {\n            writer.uint32(16).int32(message.reason);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgVoteFailed();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.team = reader.int32();\n                    break;\n                case 2:\n                    message.reason = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCCSUsrMsgVoteFailed();\n        message.team = (_a = object.team) !== null && _a !== void 0 ? _a : 0;\n        message.reason = (_b = object.reason) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgVoteSetup() {\n    return { potentialIssues: [] };\n}\nexports.CCSUsrMsgVoteSetup = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.potentialIssues) {\n            writer.uint32(10).string(v);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgVoteSetup();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.potentialIssues.push(reader.string());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgVoteSetup();\n        message.potentialIssues = ((_a = object.potentialIssues) === null || _a === void 0 ? void 0 : _a.map(e => e)) || [];\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgSendLastKillerDamageToClient() {\n    return { numHitsGiven: 0, damageGiven: 0, numHitsTaken: 0, damageTaken: 0 };\n}\nexports.CCSUsrMsgSendLastKillerDamageToClient = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.numHitsGiven !== 0) {\n            writer.uint32(8).int32(message.numHitsGiven);\n        }\n        if (message.damageGiven !== 0) {\n            writer.uint32(16).int32(message.damageGiven);\n        }\n        if (message.numHitsTaken !== 0) {\n            writer.uint32(24).int32(message.numHitsTaken);\n        }\n        if (message.damageTaken !== 0) {\n            writer.uint32(32).int32(message.damageTaken);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgSendLastKillerDamageToClient();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.numHitsGiven = reader.int32();\n                    break;\n                case 2:\n                    message.damageGiven = reader.int32();\n                    break;\n                case 3:\n                    message.numHitsTaken = reader.int32();\n                    break;\n                case 4:\n                    message.damageTaken = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCSUsrMsgSendLastKillerDamageToClient();\n        message.numHitsGiven = (_a = object.numHitsGiven) !== null && _a !== void 0 ? _a : 0;\n        message.damageGiven = (_b = object.damageGiven) !== null && _b !== void 0 ? _b : 0;\n        message.numHitsTaken = (_c = object.numHitsTaken) !== null && _c !== void 0 ? _c : 0;\n        message.damageTaken = (_d = object.damageTaken) !== null && _d !== void 0 ? _d : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgServerRankUpdate() {\n    return { rankUpdate: [] };\n}\nexports.CCSUsrMsgServerRankUpdate = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.rankUpdate) {\n            exports.CCSUsrMsgServerRankUpdate_RankUpdate.encode(v, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgServerRankUpdate();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.rankUpdate.push(exports.CCSUsrMsgServerRankUpdate_RankUpdate.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgServerRankUpdate();\n        message.rankUpdate =\n            ((_a = object.rankUpdate) === null || _a === void 0 ? void 0 : _a.map(e => exports.CCSUsrMsgServerRankUpdate_RankUpdate.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgServerRankUpdate_RankUpdate() {\n    return {\n        accountId: 0,\n        rankOld: 0,\n        rankNew: 0,\n        numWins: 0,\n        rankChange: 0,\n        rankTypeId: 0\n    };\n}\nexports.CCSUsrMsgServerRankUpdate_RankUpdate = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountId !== 0) {\n            writer.uint32(8).int32(message.accountId);\n        }\n        if (message.rankOld !== 0) {\n            writer.uint32(16).int32(message.rankOld);\n        }\n        if (message.rankNew !== 0) {\n            writer.uint32(24).int32(message.rankNew);\n        }\n        if (message.numWins !== 0) {\n            writer.uint32(32).int32(message.numWins);\n        }\n        if (message.rankChange !== 0) {\n            writer.uint32(45).float(message.rankChange);\n        }\n        if (message.rankTypeId !== 0) {\n            writer.uint32(48).int32(message.rankTypeId);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgServerRankUpdate_RankUpdate();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountId = reader.int32();\n                    break;\n                case 2:\n                    message.rankOld = reader.int32();\n                    break;\n                case 3:\n                    message.rankNew = reader.int32();\n                    break;\n                case 4:\n                    message.numWins = reader.int32();\n                    break;\n                case 5:\n                    message.rankChange = reader.float();\n                    break;\n                case 6:\n                    message.rankTypeId = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f;\n        const message = createBaseCCSUsrMsgServerRankUpdate_RankUpdate();\n        message.accountId = (_a = object.accountId) !== null && _a !== void 0 ? _a : 0;\n        message.rankOld = (_b = object.rankOld) !== null && _b !== void 0 ? _b : 0;\n        message.rankNew = (_c = object.rankNew) !== null && _c !== void 0 ? _c : 0;\n        message.numWins = (_d = object.numWins) !== null && _d !== void 0 ? _d : 0;\n        message.rankChange = (_e = object.rankChange) !== null && _e !== void 0 ? _e : 0;\n        message.rankTypeId = (_f = object.rankTypeId) !== null && _f !== void 0 ? _f : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgXpUpdate() {\n    return { data: undefined };\n}\nexports.CCSUsrMsgXpUpdate = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.data !== undefined) {\n            cstrike15_gcmessages_1.CMsgGCCstrike15V2GC2ServerNotifyXPRewarded.encode(message.data, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgXpUpdate();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.data = cstrike15_gcmessages_1.CMsgGCCstrike15V2GC2ServerNotifyXPRewarded.decode(reader, reader.uint32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        const message = createBaseCCSUsrMsgXpUpdate();\n        message.data =\n            object.data !== undefined && object.data !== null\n                ? cstrike15_gcmessages_1.CMsgGCCstrike15V2GC2ServerNotifyXPRewarded.fromPartial(object.data)\n                : undefined;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgItemPickup() {\n    return { item: \"\" };\n}\nexports.CCSUsrMsgItemPickup = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.item !== \"\") {\n            writer.uint32(10).string(message.item);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgItemPickup();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.item = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgItemPickup();\n        message.item = (_a = object.item) !== null && _a !== void 0 ? _a : \"\";\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgShowMenu() {\n    return { bitsValidSlots: 0, displayTime: 0, menuString: \"\" };\n}\nexports.CCSUsrMsgShowMenu = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.bitsValidSlots !== 0) {\n            writer.uint32(8).int32(message.bitsValidSlots);\n        }\n        if (message.displayTime !== 0) {\n            writer.uint32(16).int32(message.displayTime);\n        }\n        if (message.menuString !== \"\") {\n            writer.uint32(26).string(message.menuString);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgShowMenu();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.bitsValidSlots = reader.int32();\n                    break;\n                case 2:\n                    message.displayTime = reader.int32();\n                    break;\n                case 3:\n                    message.menuString = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCCSUsrMsgShowMenu();\n        message.bitsValidSlots = (_a = object.bitsValidSlots) !== null && _a !== void 0 ? _a : 0;\n        message.displayTime = (_b = object.displayTime) !== null && _b !== void 0 ? _b : 0;\n        message.menuString = (_c = object.menuString) !== null && _c !== void 0 ? _c : \"\";\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgBarTime() {\n    return { time: \"\" };\n}\nexports.CCSUsrMsgBarTime = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.time !== \"\") {\n            writer.uint32(10).string(message.time);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgBarTime();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.time = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgBarTime();\n        message.time = (_a = object.time) !== null && _a !== void 0 ? _a : \"\";\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgAmmoDenied() {\n    return { ammoIdx: 0 };\n}\nexports.CCSUsrMsgAmmoDenied = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.ammoIdx !== 0) {\n            writer.uint32(8).int32(message.ammoIdx);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgAmmoDenied();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.ammoIdx = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgAmmoDenied();\n        message.ammoIdx = (_a = object.ammoIdx) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgMarkAchievement() {\n    return { achievement: \"\" };\n}\nexports.CCSUsrMsgMarkAchievement = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.achievement !== \"\") {\n            writer.uint32(10).string(message.achievement);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgMarkAchievement();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.achievement = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgMarkAchievement();\n        message.achievement = (_a = object.achievement) !== null && _a !== void 0 ? _a : \"\";\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgMatchStatsUpdate() {\n    return { update: \"\" };\n}\nexports.CCSUsrMsgMatchStatsUpdate = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.update !== \"\") {\n            writer.uint32(10).string(message.update);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgMatchStatsUpdate();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.update = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgMatchStatsUpdate();\n        message.update = (_a = object.update) !== null && _a !== void 0 ? _a : \"\";\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgItemDrop() {\n    return { itemid: Long.ZERO, death: false };\n}\nexports.CCSUsrMsgItemDrop = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.itemid.isZero()) {\n            writer.uint32(8).int64(message.itemid);\n        }\n        if (message.death === true) {\n            writer.uint32(16).bool(message.death);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgItemDrop();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.itemid = reader.int64();\n                    break;\n                case 2:\n                    message.death = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgItemDrop();\n        message.itemid =\n            object.itemid !== undefined && object.itemid !== null\n                ? Long.fromValue(object.itemid)\n                : Long.ZERO;\n        message.death = (_a = object.death) !== null && _a !== void 0 ? _a : false;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgGlowPropTurnOff() {\n    return { entidx: 0 };\n}\nexports.CCSUsrMsgGlowPropTurnOff = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.entidx !== 0) {\n            writer.uint32(8).int32(message.entidx);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgGlowPropTurnOff();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.entidx = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgGlowPropTurnOff();\n        message.entidx = (_a = object.entidx) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgRoundBackupFilenames() {\n    return { count: 0, index: 0, filename: \"\", nicename: \"\" };\n}\nexports.CCSUsrMsgRoundBackupFilenames = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.count !== 0) {\n            writer.uint32(8).int32(message.count);\n        }\n        if (message.index !== 0) {\n            writer.uint32(16).int32(message.index);\n        }\n        if (message.filename !== \"\") {\n            writer.uint32(26).string(message.filename);\n        }\n        if (message.nicename !== \"\") {\n            writer.uint32(34).string(message.nicename);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgRoundBackupFilenames();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.count = reader.int32();\n                    break;\n                case 2:\n                    message.index = reader.int32();\n                    break;\n                case 3:\n                    message.filename = reader.string();\n                    break;\n                case 4:\n                    message.nicename = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCSUsrMsgRoundBackupFilenames();\n        message.count = (_a = object.count) !== null && _a !== void 0 ? _a : 0;\n        message.index = (_b = object.index) !== null && _b !== void 0 ? _b : 0;\n        message.filename = (_c = object.filename) !== null && _c !== void 0 ? _c : \"\";\n        message.nicename = (_d = object.nicename) !== null && _d !== void 0 ? _d : \"\";\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgSSUI() {\n    return { show: false, startTime: 0, endTime: 0 };\n}\nexports.CCSUsrMsgSSUI = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.show === true) {\n            writer.uint32(8).bool(message.show);\n        }\n        if (message.startTime !== 0) {\n            writer.uint32(21).float(message.startTime);\n        }\n        if (message.endTime !== 0) {\n            writer.uint32(29).float(message.endTime);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgSSUI();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.show = reader.bool();\n                    break;\n                case 2:\n                    message.startTime = reader.float();\n                    break;\n                case 3:\n                    message.endTime = reader.float();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCCSUsrMsgSSUI();\n        message.show = (_a = object.show) !== null && _a !== void 0 ? _a : false;\n        message.startTime = (_b = object.startTime) !== null && _b !== void 0 ? _b : 0;\n        message.endTime = (_c = object.endTime) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgSurvivalStats() {\n    return { xuid: Long.UZERO, facts: [], users: [], damages: [], ticknumber: 0 };\n}\nexports.CCSUsrMsgSurvivalStats = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.xuid.isZero()) {\n            writer.uint32(8).uint64(message.xuid);\n        }\n        for (const v of message.facts) {\n            exports.CCSUsrMsgSurvivalStats_Fact.encode(v, writer.uint32(18).fork()).ldelim();\n        }\n        for (const v of message.users) {\n            exports.CCSUsrMsgSurvivalStats_Placement.encode(v, writer.uint32(26).fork()).ldelim();\n        }\n        for (const v of message.damages) {\n            exports.CCSUsrMsgSurvivalStats_Damage.encode(v, writer.uint32(42).fork()).ldelim();\n        }\n        if (message.ticknumber !== 0) {\n            writer.uint32(32).int32(message.ticknumber);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgSurvivalStats();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.xuid = reader.uint64();\n                    break;\n                case 2:\n                    message.facts.push(exports.CCSUsrMsgSurvivalStats_Fact.decode(reader, reader.uint32()));\n                    break;\n                case 3:\n                    message.users.push(exports.CCSUsrMsgSurvivalStats_Placement.decode(reader, reader.uint32()));\n                    break;\n                case 5:\n                    message.damages.push(exports.CCSUsrMsgSurvivalStats_Damage.decode(reader, reader.uint32()));\n                    break;\n                case 4:\n                    message.ticknumber = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCSUsrMsgSurvivalStats();\n        message.xuid =\n            object.xuid !== undefined && object.xuid !== null\n                ? Long.fromValue(object.xuid)\n                : Long.UZERO;\n        message.facts =\n            ((_a = object.facts) === null || _a === void 0 ? void 0 : _a.map(e => exports.CCSUsrMsgSurvivalStats_Fact.fromPartial(e))) || [];\n        message.users =\n            ((_b = object.users) === null || _b === void 0 ? void 0 : _b.map(e => exports.CCSUsrMsgSurvivalStats_Placement.fromPartial(e))) ||\n                [];\n        message.damages =\n            ((_c = object.damages) === null || _c === void 0 ? void 0 : _c.map(e => exports.CCSUsrMsgSurvivalStats_Damage.fromPartial(e))) ||\n                [];\n        message.ticknumber = (_d = object.ticknumber) !== null && _d !== void 0 ? _d : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgSurvivalStats_Fact() {\n    return { type: 0, display: 0, value: 0, interestingness: 0 };\n}\nexports.CCSUsrMsgSurvivalStats_Fact = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.type !== 0) {\n            writer.uint32(8).int32(message.type);\n        }\n        if (message.display !== 0) {\n            writer.uint32(16).int32(message.display);\n        }\n        if (message.value !== 0) {\n            writer.uint32(24).int32(message.value);\n        }\n        if (message.interestingness !== 0) {\n            writer.uint32(37).float(message.interestingness);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgSurvivalStats_Fact();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.type = reader.int32();\n                    break;\n                case 2:\n                    message.display = reader.int32();\n                    break;\n                case 3:\n                    message.value = reader.int32();\n                    break;\n                case 4:\n                    message.interestingness = reader.float();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCSUsrMsgSurvivalStats_Fact();\n        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;\n        message.display = (_b = object.display) !== null && _b !== void 0 ? _b : 0;\n        message.value = (_c = object.value) !== null && _c !== void 0 ? _c : 0;\n        message.interestingness = (_d = object.interestingness) !== null && _d !== void 0 ? _d : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgSurvivalStats_Placement() {\n    return { xuid: Long.UZERO, teamnumber: 0, placement: 0 };\n}\nexports.CCSUsrMsgSurvivalStats_Placement = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.xuid.isZero()) {\n            writer.uint32(8).uint64(message.xuid);\n        }\n        if (message.teamnumber !== 0) {\n            writer.uint32(16).int32(message.teamnumber);\n        }\n        if (message.placement !== 0) {\n            writer.uint32(24).int32(message.placement);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgSurvivalStats_Placement();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.xuid = reader.uint64();\n                    break;\n                case 2:\n                    message.teamnumber = reader.int32();\n                    break;\n                case 3:\n                    message.placement = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCCSUsrMsgSurvivalStats_Placement();\n        message.xuid =\n            object.xuid !== undefined && object.xuid !== null\n                ? Long.fromValue(object.xuid)\n                : Long.UZERO;\n        message.teamnumber = (_a = object.teamnumber) !== null && _a !== void 0 ? _a : 0;\n        message.placement = (_b = object.placement) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgSurvivalStats_Damage() {\n    return { xuid: Long.UZERO, to: 0, toHits: 0, from: 0, fromHits: 0 };\n}\nexports.CCSUsrMsgSurvivalStats_Damage = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.xuid.isZero()) {\n            writer.uint32(8).uint64(message.xuid);\n        }\n        if (message.to !== 0) {\n            writer.uint32(16).int32(message.to);\n        }\n        if (message.toHits !== 0) {\n            writer.uint32(24).int32(message.toHits);\n        }\n        if (message.from !== 0) {\n            writer.uint32(32).int32(message.from);\n        }\n        if (message.fromHits !== 0) {\n            writer.uint32(40).int32(message.fromHits);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgSurvivalStats_Damage();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.xuid = reader.uint64();\n                    break;\n                case 2:\n                    message.to = reader.int32();\n                    break;\n                case 3:\n                    message.toHits = reader.int32();\n                    break;\n                case 4:\n                    message.from = reader.int32();\n                    break;\n                case 5:\n                    message.fromHits = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCSUsrMsgSurvivalStats_Damage();\n        message.xuid =\n            object.xuid !== undefined && object.xuid !== null\n                ? Long.fromValue(object.xuid)\n                : Long.UZERO;\n        message.to = (_a = object.to) !== null && _a !== void 0 ? _a : 0;\n        message.toHits = (_b = object.toHits) !== null && _b !== void 0 ? _b : 0;\n        message.from = (_c = object.from) !== null && _c !== void 0 ? _c : 0;\n        message.fromHits = (_d = object.fromHits) !== null && _d !== void 0 ? _d : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgEndOfMatchAllPlayersData() {\n    return { allplayerdata: [], scene: 0 };\n}\nexports.CCSUsrMsgEndOfMatchAllPlayersData = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.allplayerdata) {\n            exports.CCSUsrMsgEndOfMatchAllPlayersData_PlayerData.encode(v, writer.uint32(10).fork()).ldelim();\n        }\n        if (message.scene !== 0) {\n            writer.uint32(16).int32(message.scene);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgEndOfMatchAllPlayersData();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.allplayerdata.push(exports.CCSUsrMsgEndOfMatchAllPlayersData_PlayerData.decode(reader, reader.uint32()));\n                    break;\n                case 2:\n                    message.scene = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCCSUsrMsgEndOfMatchAllPlayersData();\n        message.allplayerdata =\n            ((_a = object.allplayerdata) === null || _a === void 0 ? void 0 : _a.map(e => exports.CCSUsrMsgEndOfMatchAllPlayersData_PlayerData.fromPartial(e))) || [];\n        message.scene = (_b = object.scene) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgEndOfMatchAllPlayersData_Accolade() {\n    return { eaccolade: 0, value: 0, position: 0 };\n}\nexports.CCSUsrMsgEndOfMatchAllPlayersData_Accolade = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.eaccolade !== 0) {\n            writer.uint32(8).int32(message.eaccolade);\n        }\n        if (message.value !== 0) {\n            writer.uint32(21).float(message.value);\n        }\n        if (message.position !== 0) {\n            writer.uint32(24).int32(message.position);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgEndOfMatchAllPlayersData_Accolade();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.eaccolade = reader.int32();\n                    break;\n                case 2:\n                    message.value = reader.float();\n                    break;\n                case 3:\n                    message.position = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCCSUsrMsgEndOfMatchAllPlayersData_Accolade();\n        message.eaccolade = (_a = object.eaccolade) !== null && _a !== void 0 ? _a : 0;\n        message.value = (_b = object.value) !== null && _b !== void 0 ? _b : 0;\n        message.position = (_c = object.position) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgEndOfMatchAllPlayersData_PlayerData() {\n    return {\n        entindex: 0,\n        xuid: Long.UZERO,\n        name: \"\",\n        teamnumber: 0,\n        nomination: undefined,\n        items: [],\n        playercolor: 0,\n        isbot: false\n    };\n}\nexports.CCSUsrMsgEndOfMatchAllPlayersData_PlayerData = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.entindex !== 0) {\n            writer.uint32(8).int32(message.entindex);\n        }\n        if (!message.xuid.isZero()) {\n            writer.uint32(16).uint64(message.xuid);\n        }\n        if (message.name !== \"\") {\n            writer.uint32(26).string(message.name);\n        }\n        if (message.teamnumber !== 0) {\n            writer.uint32(32).int32(message.teamnumber);\n        }\n        if (message.nomination !== undefined) {\n            exports.CCSUsrMsgEndOfMatchAllPlayersData_Accolade.encode(message.nomination, writer.uint32(42).fork()).ldelim();\n        }\n        for (const v of message.items) {\n            cstrike15_gcmessages_1.CEconItemPreviewDataBlock.encode(v, writer.uint32(50).fork()).ldelim();\n        }\n        if (message.playercolor !== 0) {\n            writer.uint32(56).int32(message.playercolor);\n        }\n        if (message.isbot === true) {\n            writer.uint32(64).bool(message.isbot);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgEndOfMatchAllPlayersData_PlayerData();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.entindex = reader.int32();\n                    break;\n                case 2:\n                    message.xuid = reader.uint64();\n                    break;\n                case 3:\n                    message.name = reader.string();\n                    break;\n                case 4:\n                    message.teamnumber = reader.int32();\n                    break;\n                case 5:\n                    message.nomination =\n                        exports.CCSUsrMsgEndOfMatchAllPlayersData_Accolade.decode(reader, reader.uint32());\n                    break;\n                case 6:\n                    message.items.push(cstrike15_gcmessages_1.CEconItemPreviewDataBlock.decode(reader, reader.uint32()));\n                    break;\n                case 7:\n                    message.playercolor = reader.int32();\n                    break;\n                case 8:\n                    message.isbot = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f;\n        const message = createBaseCCSUsrMsgEndOfMatchAllPlayersData_PlayerData();\n        message.entindex = (_a = object.entindex) !== null && _a !== void 0 ? _a : 0;\n        message.xuid =\n            object.xuid !== undefined && object.xuid !== null\n                ? Long.fromValue(object.xuid)\n                : Long.UZERO;\n        message.name = (_b = object.name) !== null && _b !== void 0 ? _b : \"\";\n        message.teamnumber = (_c = object.teamnumber) !== null && _c !== void 0 ? _c : 0;\n        message.nomination =\n            object.nomination !== undefined && object.nomination !== null\n                ? exports.CCSUsrMsgEndOfMatchAllPlayersData_Accolade.fromPartial(object.nomination)\n                : undefined;\n        message.items =\n            ((_d = object.items) === null || _d === void 0 ? void 0 : _d.map(e => cstrike15_gcmessages_1.CEconItemPreviewDataBlock.fromPartial(e))) || [];\n        message.playercolor = (_e = object.playercolor) !== null && _e !== void 0 ? _e : 0;\n        message.isbot = (_f = object.isbot) !== null && _f !== void 0 ? _f : false;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgRoundImpactScoreData() {\n    return { initConditions: undefined, allRisEventData: [] };\n}\nexports.CCSUsrMsgRoundImpactScoreData = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.initConditions !== undefined) {\n            exports.CCSUsrMsgRoundImpactScoreData_InitialConditions.encode(message.initConditions, writer.uint32(10).fork()).ldelim();\n        }\n        for (const v of message.allRisEventData) {\n            exports.CCSUsrMsgRoundImpactScoreData_RisEvent.encode(v, writer.uint32(18).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgRoundImpactScoreData();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.initConditions =\n                        exports.CCSUsrMsgRoundImpactScoreData_InitialConditions.decode(reader, reader.uint32());\n                    break;\n                case 2:\n                    message.allRisEventData.push(exports.CCSUsrMsgRoundImpactScoreData_RisEvent.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgRoundImpactScoreData();\n        message.initConditions =\n            object.initConditions !== undefined && object.initConditions !== null\n                ? exports.CCSUsrMsgRoundImpactScoreData_InitialConditions.fromPartial(object.initConditions)\n                : undefined;\n        message.allRisEventData =\n            ((_a = object.allRisEventData) === null || _a === void 0 ? void 0 : _a.map(e => exports.CCSUsrMsgRoundImpactScoreData_RisEvent.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgRoundImpactScoreData_RisEvent() {\n    return {\n        timestamp: 0,\n        terroristOdds: 0,\n        ctAlive: 0,\n        tAlive: 0,\n        victimData: undefined,\n        objectiveData: undefined,\n        allDamageData: []\n    };\n}\nexports.CCSUsrMsgRoundImpactScoreData_RisEvent = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.timestamp !== 0) {\n            writer.uint32(13).float(message.timestamp);\n        }\n        if (message.terroristOdds !== 0) {\n            writer.uint32(16).int32(message.terroristOdds);\n        }\n        if (message.ctAlive !== 0) {\n            writer.uint32(24).int32(message.ctAlive);\n        }\n        if (message.tAlive !== 0) {\n            writer.uint32(32).int32(message.tAlive);\n        }\n        if (message.victimData !== undefined) {\n            exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Victim.encode(message.victimData, writer.uint32(42).fork()).ldelim();\n        }\n        if (message.objectiveData !== undefined) {\n            exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Objective.encode(message.objectiveData, writer.uint32(50).fork()).ldelim();\n        }\n        for (const v of message.allDamageData) {\n            exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Damage.encode(v, writer.uint32(58).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgRoundImpactScoreData_RisEvent();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.timestamp = reader.float();\n                    break;\n                case 2:\n                    message.terroristOdds = reader.int32();\n                    break;\n                case 3:\n                    message.ctAlive = reader.int32();\n                    break;\n                case 4:\n                    message.tAlive = reader.int32();\n                    break;\n                case 5:\n                    message.victimData =\n                        exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Victim.decode(reader, reader.uint32());\n                    break;\n                case 6:\n                    message.objectiveData =\n                        exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Objective.decode(reader, reader.uint32());\n                    break;\n                case 7:\n                    message.allDamageData.push(exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Damage.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseCCSUsrMsgRoundImpactScoreData_RisEvent();\n        message.timestamp = (_a = object.timestamp) !== null && _a !== void 0 ? _a : 0;\n        message.terroristOdds = (_b = object.terroristOdds) !== null && _b !== void 0 ? _b : 0;\n        message.ctAlive = (_c = object.ctAlive) !== null && _c !== void 0 ? _c : 0;\n        message.tAlive = (_d = object.tAlive) !== null && _d !== void 0 ? _d : 0;\n        message.victimData =\n            object.victimData !== undefined && object.victimData !== null\n                ? exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Victim.fromPartial(object.victimData)\n                : undefined;\n        message.objectiveData =\n            object.objectiveData !== undefined && object.objectiveData !== null\n                ? exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Objective.fromPartial(object.objectiveData)\n                : undefined;\n        message.allDamageData =\n            ((_e = object.allDamageData) === null || _e === void 0 ? void 0 : _e.map(e => exports.CCSUsrMsgRoundImpactScoreData_RisEvent_Damage.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Victim() {\n    return {\n        teamNumber: 0,\n        entindex: 0,\n        xuid: Long.UZERO,\n        color: 0,\n        isBot: false,\n        isDead: false\n    };\n}\nexports.CCSUsrMsgRoundImpactScoreData_RisEvent_Victim = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.teamNumber !== 0) {\n            writer.uint32(8).int32(message.teamNumber);\n        }\n        if (message.entindex !== 0) {\n            writer.uint32(16).int32(message.entindex);\n        }\n        if (!message.xuid.isZero()) {\n            writer.uint32(24).uint64(message.xuid);\n        }\n        if (message.color !== 0) {\n            writer.uint32(32).int32(message.color);\n        }\n        if (message.isBot === true) {\n            writer.uint32(40).bool(message.isBot);\n        }\n        if (message.isDead === true) {\n            writer.uint32(48).bool(message.isDead);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Victim();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.teamNumber = reader.int32();\n                    break;\n                case 2:\n                    message.entindex = reader.int32();\n                    break;\n                case 3:\n                    message.xuid = reader.uint64();\n                    break;\n                case 4:\n                    message.color = reader.int32();\n                    break;\n                case 5:\n                    message.isBot = reader.bool();\n                    break;\n                case 6:\n                    message.isDead = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Victim();\n        message.teamNumber = (_a = object.teamNumber) !== null && _a !== void 0 ? _a : 0;\n        message.entindex = (_b = object.entindex) !== null && _b !== void 0 ? _b : 0;\n        message.xuid =\n            object.xuid !== undefined && object.xuid !== null\n                ? Long.fromValue(object.xuid)\n                : Long.UZERO;\n        message.color = (_c = object.color) !== null && _c !== void 0 ? _c : 0;\n        message.isBot = (_d = object.isBot) !== null && _d !== void 0 ? _d : false;\n        message.isDead = (_e = object.isDead) !== null && _e !== void 0 ? _e : false;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Objective() {\n    return { type: 0 };\n}\nexports.CCSUsrMsgRoundImpactScoreData_RisEvent_Objective = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.type !== 0) {\n            writer.uint32(8).int32(message.type);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Objective();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.type = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Objective();\n        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Damage() {\n    return {\n        targetEntindex: 0,\n        targetXuid: Long.UZERO,\n        healthRemoved: 0,\n        numHits: 0,\n        returnHealthRemoved: 0,\n        numReturnHits: 0\n    };\n}\nexports.CCSUsrMsgRoundImpactScoreData_RisEvent_Damage = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.targetEntindex !== 0) {\n            writer.uint32(8).int32(message.targetEntindex);\n        }\n        if (!message.targetXuid.isZero()) {\n            writer.uint32(16).uint64(message.targetXuid);\n        }\n        if (message.healthRemoved !== 0) {\n            writer.uint32(24).int32(message.healthRemoved);\n        }\n        if (message.numHits !== 0) {\n            writer.uint32(32).int32(message.numHits);\n        }\n        if (message.returnHealthRemoved !== 0) {\n            writer.uint32(40).int32(message.returnHealthRemoved);\n        }\n        if (message.numReturnHits !== 0) {\n            writer.uint32(48).int32(message.numReturnHits);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Damage();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.targetEntindex = reader.int32();\n                    break;\n                case 2:\n                    message.targetXuid = reader.uint64();\n                    break;\n                case 3:\n                    message.healthRemoved = reader.int32();\n                    break;\n                case 4:\n                    message.numHits = reader.int32();\n                    break;\n                case 5:\n                    message.returnHealthRemoved = reader.int32();\n                    break;\n                case 6:\n                    message.numReturnHits = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseCCSUsrMsgRoundImpactScoreData_RisEvent_Damage();\n        message.targetEntindex = (_a = object.targetEntindex) !== null && _a !== void 0 ? _a : 0;\n        message.targetXuid =\n            object.targetXuid !== undefined && object.targetXuid !== null\n                ? Long.fromValue(object.targetXuid)\n                : Long.UZERO;\n        message.healthRemoved = (_b = object.healthRemoved) !== null && _b !== void 0 ? _b : 0;\n        message.numHits = (_c = object.numHits) !== null && _c !== void 0 ? _c : 0;\n        message.returnHealthRemoved = (_d = object.returnHealthRemoved) !== null && _d !== void 0 ? _d : 0;\n        message.numReturnHits = (_e = object.numReturnHits) !== null && _e !== void 0 ? _e : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgRoundImpactScoreData_InitialConditions() {\n    return { ctEquipValue: 0, tEquipValue: 0, terroristOdds: 0 };\n}\nexports.CCSUsrMsgRoundImpactScoreData_InitialConditions = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.ctEquipValue !== 0) {\n            writer.uint32(8).int32(message.ctEquipValue);\n        }\n        if (message.tEquipValue !== 0) {\n            writer.uint32(16).int32(message.tEquipValue);\n        }\n        if (message.terroristOdds !== 0) {\n            writer.uint32(24).int32(message.terroristOdds);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgRoundImpactScoreData_InitialConditions();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.ctEquipValue = reader.int32();\n                    break;\n                case 2:\n                    message.tEquipValue = reader.int32();\n                    break;\n                case 3:\n                    message.terroristOdds = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCCSUsrMsgRoundImpactScoreData_InitialConditions();\n        message.ctEquipValue = (_a = object.ctEquipValue) !== null && _a !== void 0 ? _a : 0;\n        message.tEquipValue = (_b = object.tEquipValue) !== null && _b !== void 0 ? _b : 0;\n        message.terroristOdds = (_c = object.terroristOdds) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgCurrentRoundOdds() {\n    return { odds: 0 };\n}\nexports.CCSUsrMsgCurrentRoundOdds = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.odds !== 0) {\n            writer.uint32(8).int32(message.odds);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgCurrentRoundOdds();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.odds = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgCurrentRoundOdds();\n        message.odds = (_a = object.odds) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgDeepStats() {\n    return { stats: undefined };\n}\nexports.CCSUsrMsgDeepStats = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.stats !== undefined) {\n            cstrike15_gcmessages_1.CMsgGCCStrike15ClientDeepStats.encode(message.stats, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgDeepStats();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.stats = cstrike15_gcmessages_1.CMsgGCCStrike15ClientDeepStats.decode(reader, reader.uint32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        const message = createBaseCCSUsrMsgDeepStats();\n        message.stats =\n            object.stats !== undefined && object.stats !== null\n                ? cstrike15_gcmessages_1.CMsgGCCStrike15ClientDeepStats.fromPartial(object.stats)\n                : undefined;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgResetHud() {\n    return { reset: false };\n}\nexports.CCSUsrMsgResetHud = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.reset === true) {\n            writer.uint32(8).bool(message.reset);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgResetHud();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.reset = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgResetHud();\n        message.reset = (_a = object.reset) !== null && _a !== void 0 ? _a : false;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgGameTitle() {\n    return { dummy: 0 };\n}\nexports.CCSUsrMsgGameTitle = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.dummy !== 0) {\n            writer.uint32(8).int32(message.dummy);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgGameTitle();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.dummy = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgGameTitle();\n        message.dummy = (_a = object.dummy) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgRequestState() {\n    return { dummy: 0 };\n}\nexports.CCSUsrMsgRequestState = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.dummy !== 0) {\n            writer.uint32(8).int32(message.dummy);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgRequestState();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.dummy = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgRequestState();\n        message.dummy = (_a = object.dummy) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgStopSpectatorMode() {\n    return { dummy: 0 };\n}\nexports.CCSUsrMsgStopSpectatorMode = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.dummy !== 0) {\n            writer.uint32(8).int32(message.dummy);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgStopSpectatorMode();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.dummy = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgStopSpectatorMode();\n        message.dummy = (_a = object.dummy) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgDisconnectToLobby() {\n    return { dummy: 0 };\n}\nexports.CCSUsrMsgDisconnectToLobby = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.dummy !== 0) {\n            writer.uint32(8).int32(message.dummy);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgDisconnectToLobby();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.dummy = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgDisconnectToLobby();\n        message.dummy = (_a = object.dummy) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgWarmupHasEnded() {\n    return { dummy: 0 };\n}\nexports.CCSUsrMsgWarmupHasEnded = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.dummy !== 0) {\n            writer.uint32(8).int32(message.dummy);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgWarmupHasEnded();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.dummy = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgWarmupHasEnded();\n        message.dummy = (_a = object.dummy) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgClientInfo() {\n    return { dummy: 0 };\n}\nexports.CCSUsrMsgClientInfo = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.dummy !== 0) {\n            writer.uint32(8).int32(message.dummy);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgClientInfo();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.dummy = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgClientInfo();\n        message.dummy = (_a = object.dummy) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgServerRankRevealAll() {\n    return { secondsTillShutdown: 0, reservation: undefined };\n}\nexports.CCSUsrMsgServerRankRevealAll = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.secondsTillShutdown !== 0) {\n            writer.uint32(8).int32(message.secondsTillShutdown);\n        }\n        if (message.reservation !== undefined) {\n            cstrike15_gcmessages_1.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.encode(message.reservation, writer.uint32(18).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgServerRankRevealAll();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.secondsTillShutdown = reader.int32();\n                    break;\n                case 2:\n                    message.reservation =\n                        cstrike15_gcmessages_1.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.decode(reader, reader.uint32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCSUsrMsgServerRankRevealAll();\n        message.secondsTillShutdown = (_a = object.secondsTillShutdown) !== null && _a !== void 0 ? _a : 0;\n        message.reservation =\n            object.reservation !== undefined && object.reservation !== null\n                ? cstrike15_gcmessages_1.CMsgGCCStrike15V2MatchmakingGC2ServerReserve.fromPartial(object.reservation)\n                : undefined;\n        return message;\n    }\n};\nfunction createBaseCCSUsrMsgUtilMsg() {\n    return { utilAction: \"\", util1: 0, util2: 0, util3: 0, util4: 0, util5: 0 };\n}\nexports.CCSUsrMsgUtilMsg = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.utilAction !== \"\") {\n            writer.uint32(10).string(message.utilAction);\n        }\n        if (message.util1 !== 0) {\n            writer.uint32(16).int32(message.util1);\n        }\n        if (message.util2 !== 0) {\n            writer.uint32(24).int32(message.util2);\n        }\n        if (message.util3 !== 0) {\n            writer.uint32(32).int32(message.util3);\n        }\n        if (message.util4 !== 0) {\n            writer.uint32(40).int32(message.util4);\n        }\n        if (message.util5 !== 0) {\n            writer.uint32(48).int32(message.util5);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCSUsrMsgUtilMsg();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.utilAction = reader.string();\n                    break;\n                case 2:\n                    message.util1 = reader.int32();\n                    break;\n                case 3:\n                    message.util2 = reader.int32();\n                    break;\n                case 4:\n                    message.util3 = reader.int32();\n                    break;\n                case 5:\n                    message.util4 = reader.int32();\n                    break;\n                case 6:\n                    message.util5 = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f;\n        const message = createBaseCCSUsrMsgUtilMsg();\n        message.utilAction = (_a = object.utilAction) !== null && _a !== void 0 ? _a : \"\";\n        message.util1 = (_b = object.util1) !== null && _b !== void 0 ? _b : 0;\n        message.util2 = (_c = object.util2) !== null && _c !== void 0 ? _c : 0;\n        message.util3 = (_d = object.util3) !== null && _d !== void 0 ? _d : 0;\n        message.util4 = (_e = object.util4) !== null && _e !== void 0 ? _e : 0;\n        message.util5 = (_f = object.util5) !== null && _f !== void 0 ? _f : 0;\n        return message;\n    }\n};\n// If you get a compile-error about 'Constructor<Long> and ... have no overlap',\n// add '--ts_proto_opt=esModuleInterop=true' as a flag when calling 'protoc'.\nif (minimal_1.util.Long !== Long) {\n    minimal_1.util.Long = Long;\n    (0, minimal_1.configure)();\n}\n//# sourceMappingURL=cstrike15_usermessages.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.CEngineGotvSyncPacket = exports.protobufPackage = void 0;\n/* eslint-disable */\nconst minimal_1 = require(\"protobufjs/minimal\");\nconst Long = require(\"long\");\nexports.protobufPackage = \"\";\nfunction createBaseCEngineGotvSyncPacket() {\n    return {\n        matchId: Long.UZERO,\n        instanceId: 0,\n        signupfragment: 0,\n        currentfragment: 0,\n        tickrate: 0,\n        tick: 0,\n        rtdelay: 0,\n        rcvage: 0,\n        keyframeInterval: 0,\n        cdndelay: 0\n    };\n}\nexports.CEngineGotvSyncPacket = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (!message.matchId.isZero()) {\n            writer.uint32(8).uint64(message.matchId);\n        }\n        if (message.instanceId !== 0) {\n            writer.uint32(16).uint32(message.instanceId);\n        }\n        if (message.signupfragment !== 0) {\n            writer.uint32(24).uint32(message.signupfragment);\n        }\n        if (message.currentfragment !== 0) {\n            writer.uint32(32).uint32(message.currentfragment);\n        }\n        if (message.tickrate !== 0) {\n            writer.uint32(45).float(message.tickrate);\n        }\n        if (message.tick !== 0) {\n            writer.uint32(48).uint32(message.tick);\n        }\n        if (message.rtdelay !== 0) {\n            writer.uint32(69).float(message.rtdelay);\n        }\n        if (message.rcvage !== 0) {\n            writer.uint32(77).float(message.rcvage);\n        }\n        if (message.keyframeInterval !== 0) {\n            writer.uint32(85).float(message.keyframeInterval);\n        }\n        if (message.cdndelay !== 0) {\n            writer.uint32(88).uint32(message.cdndelay);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCEngineGotvSyncPacket();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.matchId = reader.uint64();\n                    break;\n                case 2:\n                    message.instanceId = reader.uint32();\n                    break;\n                case 3:\n                    message.signupfragment = reader.uint32();\n                    break;\n                case 4:\n                    message.currentfragment = reader.uint32();\n                    break;\n                case 5:\n                    message.tickrate = reader.float();\n                    break;\n                case 6:\n                    message.tick = reader.uint32();\n                    break;\n                case 8:\n                    message.rtdelay = reader.float();\n                    break;\n                case 9:\n                    message.rcvage = reader.float();\n                    break;\n                case 10:\n                    message.keyframeInterval = reader.float();\n                    break;\n                case 11:\n                    message.cdndelay = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j;\n        const message = createBaseCEngineGotvSyncPacket();\n        message.matchId =\n            object.matchId !== undefined && object.matchId !== null\n                ? Long.fromValue(object.matchId)\n                : Long.UZERO;\n        message.instanceId = (_a = object.instanceId) !== null && _a !== void 0 ? _a : 0;\n        message.signupfragment = (_b = object.signupfragment) !== null && _b !== void 0 ? _b : 0;\n        message.currentfragment = (_c = object.currentfragment) !== null && _c !== void 0 ? _c : 0;\n        message.tickrate = (_d = object.tickrate) !== null && _d !== void 0 ? _d : 0;\n        message.tick = (_e = object.tick) !== null && _e !== void 0 ? _e : 0;\n        message.rtdelay = (_f = object.rtdelay) !== null && _f !== void 0 ? _f : 0;\n        message.rcvage = (_g = object.rcvage) !== null && _g !== void 0 ? _g : 0;\n        message.keyframeInterval = (_h = object.keyframeInterval) !== null && _h !== void 0 ? _h : 0;\n        message.cdndelay = (_j = object.cdndelay) !== null && _j !== void 0 ? _j : 0;\n        return message;\n    }\n};\n// If you get a compile-error about 'Constructor<Long> and ... have no overlap',\n// add '--ts_proto_opt=esModuleInterop=true' as a flag when calling 'protoc'.\nif (minimal_1.util.Long !== Long) {\n    minimal_1.util.Long = Long;\n    (0, minimal_1.configure)();\n}\n//# sourceMappingURL=engine_gcmessages.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.CSVCMsgGetCvarValue = exports.CSVCMsgSplitScreen = exports.CSVCMsgBSPDecal = exports.CSVCMsgPrefetch = exports.CSVCMsgCrosshairAngle = exports.CSVCMsgFixAngle = exports.CSVCMsgVoiceData = exports.CSVCMsgVoiceInit = exports.CSVCMsgUpdateStringTable = exports.CSVCMsgCreateStringTable = exports.CSVCMsgSetView = exports.CSVCMsgSetPause = exports.CSVCMsgPrint = exports.CSVCMsgSendTable_sendpropT = exports.CSVCMsgSendTable = exports.CSVCMsgClassInfo_classT = exports.CSVCMsgClassInfo = exports.CSVCMsgServerInfo = exports.CCLCMsgCmdKeyValues = exports.CCLCMsgSplitPlayerConnect = exports.CCLCMsgLoadingProgress = exports.CCLCMsgFileCRCCheck = exports.CCLCMsgRespondCvarValue = exports.CCLCMsgListenEvents = exports.CCLCMsgBaselineAck = exports.CCLCMsgVoiceData = exports.CCLCMsgMove = exports.CCLCMsgClientInfo = exports.CNETMsgPlayerAvatarData = exports.CNETMsgSplitScreenUser = exports.CNETMsgFile = exports.CNETMsgDisconnect = exports.CNETMsgNOP = exports.CNETMsgSetConVar = exports.CMsgCVars_CVar = exports.CMsgCVars = exports.CNETMsgSignonState = exports.CNETMsgStringCmd = exports.CNETMsgTick = exports.CMsgRGBA = exports.CMsgQAngle = exports.CMsgVector2D = exports.CMsgVector = exports.ReplayEventTypeT = exports.SVCMessages = exports.ESplitScreenMessageType = exports.VoiceDataFormatT = exports.CLCMessages = exports.NETMessages = exports.protobufPackage = void 0;\nexports.CSVCMsgBroadcastCommand = exports.CCLCMsgHltvReplay = exports.CSVCMsgHltvReplay = exports.CSVCMsgEncryptedData = exports.CSVCMsgCmdKeyValues = exports.CSVCMsgEntityMsg = exports.CSVCMsgSounds_sounddataT = exports.CSVCMsgSounds = exports.CSVCMsgPacketEntities = exports.CSVCMsgTempEntities = exports.CSVCMsgGameEventList_descriptorT = exports.CSVCMsgGameEventList_keyT = exports.CSVCMsgGameEventList = exports.CSVCMsgGameEvent_keyT = exports.CSVCMsgGameEvent = exports.CSVCMsgPaintmapData = exports.CSVCMsgUserMessage = exports.CSVCMsgMenu = void 0;\n/* eslint-disable */\nconst minimal_1 = require(\"protobufjs/minimal\");\nconst Long = require(\"long\");\nexports.protobufPackage = \"\";\nvar NETMessages;\n(function (NETMessages) {\n    NETMessages[NETMessages[\"net_NOP\"] = 0] = \"net_NOP\";\n    NETMessages[NETMessages[\"net_Disconnect\"] = 1] = \"net_Disconnect\";\n    NETMessages[NETMessages[\"net_File\"] = 2] = \"net_File\";\n    NETMessages[NETMessages[\"net_SplitScreenUser\"] = 3] = \"net_SplitScreenUser\";\n    NETMessages[NETMessages[\"net_Tick\"] = 4] = \"net_Tick\";\n    NETMessages[NETMessages[\"net_StringCmd\"] = 5] = \"net_StringCmd\";\n    NETMessages[NETMessages[\"net_SetConVar\"] = 6] = \"net_SetConVar\";\n    NETMessages[NETMessages[\"net_SignonState\"] = 7] = \"net_SignonState\";\n    NETMessages[NETMessages[\"net_PlayerAvatarData\"] = 100] = \"net_PlayerAvatarData\";\n})(NETMessages = exports.NETMessages || (exports.NETMessages = {}));\nvar CLCMessages;\n(function (CLCMessages) {\n    CLCMessages[CLCMessages[\"clc_ClientInfo\"] = 8] = \"clc_ClientInfo\";\n    CLCMessages[CLCMessages[\"clc_Move\"] = 9] = \"clc_Move\";\n    CLCMessages[CLCMessages[\"clc_VoiceData\"] = 10] = \"clc_VoiceData\";\n    CLCMessages[CLCMessages[\"clc_BaselineAck\"] = 11] = \"clc_BaselineAck\";\n    CLCMessages[CLCMessages[\"clc_ListenEvents\"] = 12] = \"clc_ListenEvents\";\n    CLCMessages[CLCMessages[\"clc_RespondCvarValue\"] = 13] = \"clc_RespondCvarValue\";\n    CLCMessages[CLCMessages[\"clc_FileCRCCheck\"] = 14] = \"clc_FileCRCCheck\";\n    CLCMessages[CLCMessages[\"clc_LoadingProgress\"] = 15] = \"clc_LoadingProgress\";\n    CLCMessages[CLCMessages[\"clc_SplitPlayerConnect\"] = 16] = \"clc_SplitPlayerConnect\";\n    CLCMessages[CLCMessages[\"clc_ClientMessage\"] = 17] = \"clc_ClientMessage\";\n    CLCMessages[CLCMessages[\"clc_CmdKeyValues\"] = 18] = \"clc_CmdKeyValues\";\n    CLCMessages[CLCMessages[\"clc_HltvReplay\"] = 20] = \"clc_HltvReplay\";\n})(CLCMessages = exports.CLCMessages || (exports.CLCMessages = {}));\nvar VoiceDataFormatT;\n(function (VoiceDataFormatT) {\n    VoiceDataFormatT[VoiceDataFormatT[\"VOICEDATA_FORMAT_STEAM\"] = 0] = \"VOICEDATA_FORMAT_STEAM\";\n    VoiceDataFormatT[VoiceDataFormatT[\"VOICEDATA_FORMAT_ENGINE\"] = 1] = \"VOICEDATA_FORMAT_ENGINE\";\n})(VoiceDataFormatT = exports.VoiceDataFormatT || (exports.VoiceDataFormatT = {}));\nvar ESplitScreenMessageType;\n(function (ESplitScreenMessageType) {\n    ESplitScreenMessageType[ESplitScreenMessageType[\"MSG_SPLITSCREEN_ADDUSER\"] = 0] = \"MSG_SPLITSCREEN_ADDUSER\";\n    ESplitScreenMessageType[ESplitScreenMessageType[\"MSG_SPLITSCREEN_REMOVEUSER\"] = 1] = \"MSG_SPLITSCREEN_REMOVEUSER\";\n    ESplitScreenMessageType[ESplitScreenMessageType[\"MSG_SPLITSCREEN_TYPE_BITS\"] = 1] = \"MSG_SPLITSCREEN_TYPE_BITS\";\n})(ESplitScreenMessageType = exports.ESplitScreenMessageType || (exports.ESplitScreenMessageType = {}));\nvar SVCMessages;\n(function (SVCMessages) {\n    SVCMessages[SVCMessages[\"svc_ServerInfo\"] = 8] = \"svc_ServerInfo\";\n    SVCMessages[SVCMessages[\"svc_SendTable\"] = 9] = \"svc_SendTable\";\n    SVCMessages[SVCMessages[\"svc_ClassInfo\"] = 10] = \"svc_ClassInfo\";\n    SVCMessages[SVCMessages[\"svc_SetPause\"] = 11] = \"svc_SetPause\";\n    SVCMessages[SVCMessages[\"svc_CreateStringTable\"] = 12] = \"svc_CreateStringTable\";\n    SVCMessages[SVCMessages[\"svc_UpdateStringTable\"] = 13] = \"svc_UpdateStringTable\";\n    SVCMessages[SVCMessages[\"svc_VoiceInit\"] = 14] = \"svc_VoiceInit\";\n    SVCMessages[SVCMessages[\"svc_VoiceData\"] = 15] = \"svc_VoiceData\";\n    SVCMessages[SVCMessages[\"svc_Print\"] = 16] = \"svc_Print\";\n    SVCMessages[SVCMessages[\"svc_Sounds\"] = 17] = \"svc_Sounds\";\n    SVCMessages[SVCMessages[\"svc_SetView\"] = 18] = \"svc_SetView\";\n    SVCMessages[SVCMessages[\"svc_FixAngle\"] = 19] = \"svc_FixAngle\";\n    SVCMessages[SVCMessages[\"svc_CrosshairAngle\"] = 20] = \"svc_CrosshairAngle\";\n    SVCMessages[SVCMessages[\"svc_BSPDecal\"] = 21] = \"svc_BSPDecal\";\n    SVCMessages[SVCMessages[\"svc_SplitScreen\"] = 22] = \"svc_SplitScreen\";\n    SVCMessages[SVCMessages[\"svc_UserMessage\"] = 23] = \"svc_UserMessage\";\n    SVCMessages[SVCMessages[\"svc_EntityMessage\"] = 24] = \"svc_EntityMessage\";\n    SVCMessages[SVCMessages[\"svc_GameEvent\"] = 25] = \"svc_GameEvent\";\n    SVCMessages[SVCMessages[\"svc_PacketEntities\"] = 26] = \"svc_PacketEntities\";\n    SVCMessages[SVCMessages[\"svc_TempEntities\"] = 27] = \"svc_TempEntities\";\n    SVCMessages[SVCMessages[\"svc_Prefetch\"] = 28] = \"svc_Prefetch\";\n    SVCMessages[SVCMessages[\"svc_Menu\"] = 29] = \"svc_Menu\";\n    SVCMessages[SVCMessages[\"svc_GameEventList\"] = 30] = \"svc_GameEventList\";\n    SVCMessages[SVCMessages[\"svc_GetCvarValue\"] = 31] = \"svc_GetCvarValue\";\n    SVCMessages[SVCMessages[\"svc_PaintmapData\"] = 33] = \"svc_PaintmapData\";\n    SVCMessages[SVCMessages[\"svc_CmdKeyValues\"] = 34] = \"svc_CmdKeyValues\";\n    SVCMessages[SVCMessages[\"svc_EncryptedData\"] = 35] = \"svc_EncryptedData\";\n    SVCMessages[SVCMessages[\"svc_HltvReplay\"] = 36] = \"svc_HltvReplay\";\n    SVCMessages[SVCMessages[\"svc_Broadcast_Command\"] = 38] = \"svc_Broadcast_Command\";\n})(SVCMessages = exports.SVCMessages || (exports.SVCMessages = {}));\nvar ReplayEventTypeT;\n(function (ReplayEventTypeT) {\n    ReplayEventTypeT[ReplayEventTypeT[\"REPLAY_EVENT_CANCEL\"] = 0] = \"REPLAY_EVENT_CANCEL\";\n    ReplayEventTypeT[ReplayEventTypeT[\"REPLAY_EVENT_DEATH\"] = 1] = \"REPLAY_EVENT_DEATH\";\n    ReplayEventTypeT[ReplayEventTypeT[\"REPLAY_EVENT_GENERIC\"] = 2] = \"REPLAY_EVENT_GENERIC\";\n    ReplayEventTypeT[ReplayEventTypeT[\"REPLAY_EVENT_STUCK_NEED_FULL_UPDATE\"] = 3] = \"REPLAY_EVENT_STUCK_NEED_FULL_UPDATE\";\n})(ReplayEventTypeT = exports.ReplayEventTypeT || (exports.ReplayEventTypeT = {}));\nfunction createBaseCMsgVector() {\n    return { x: 0, y: 0, z: 0 };\n}\nexports.CMsgVector = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.x !== 0) {\n            writer.uint32(13).float(message.x);\n        }\n        if (message.y !== 0) {\n            writer.uint32(21).float(message.y);\n        }\n        if (message.z !== 0) {\n            writer.uint32(29).float(message.z);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgVector();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.x = reader.float();\n                    break;\n                case 2:\n                    message.y = reader.float();\n                    break;\n                case 3:\n                    message.z = reader.float();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCMsgVector();\n        message.x = (_a = object.x) !== null && _a !== void 0 ? _a : 0;\n        message.y = (_b = object.y) !== null && _b !== void 0 ? _b : 0;\n        message.z = (_c = object.z) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgVector2D() {\n    return { x: 0, y: 0 };\n}\nexports.CMsgVector2D = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.x !== 0) {\n            writer.uint32(13).float(message.x);\n        }\n        if (message.y !== 0) {\n            writer.uint32(21).float(message.y);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgVector2D();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.x = reader.float();\n                    break;\n                case 2:\n                    message.y = reader.float();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCMsgVector2D();\n        message.x = (_a = object.x) !== null && _a !== void 0 ? _a : 0;\n        message.y = (_b = object.y) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgQAngle() {\n    return { x: 0, y: 0, z: 0 };\n}\nexports.CMsgQAngle = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.x !== 0) {\n            writer.uint32(13).float(message.x);\n        }\n        if (message.y !== 0) {\n            writer.uint32(21).float(message.y);\n        }\n        if (message.z !== 0) {\n            writer.uint32(29).float(message.z);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgQAngle();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.x = reader.float();\n                    break;\n                case 2:\n                    message.y = reader.float();\n                    break;\n                case 3:\n                    message.z = reader.float();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCMsgQAngle();\n        message.x = (_a = object.x) !== null && _a !== void 0 ? _a : 0;\n        message.y = (_b = object.y) !== null && _b !== void 0 ? _b : 0;\n        message.z = (_c = object.z) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseCMsgRGBA() {\n    return { r: 0, g: 0, b: 0, a: 0 };\n}\nexports.CMsgRGBA = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.r !== 0) {\n            writer.uint32(8).int32(message.r);\n        }\n        if (message.g !== 0) {\n            writer.uint32(16).int32(message.g);\n        }\n        if (message.b !== 0) {\n            writer.uint32(24).int32(message.b);\n        }\n        if (message.a !== 0) {\n            writer.uint32(32).int32(message.a);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgRGBA();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.r = reader.int32();\n                    break;\n                case 2:\n                    message.g = reader.int32();\n                    break;\n                case 3:\n                    message.b = reader.int32();\n                    break;\n                case 4:\n                    message.a = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCMsgRGBA();\n        message.r = (_a = object.r) !== null && _a !== void 0 ? _a : 0;\n        message.g = (_b = object.g) !== null && _b !== void 0 ? _b : 0;\n        message.b = (_c = object.b) !== null && _c !== void 0 ? _c : 0;\n        message.a = (_d = object.a) !== null && _d !== void 0 ? _d : 0;\n        return message;\n    }\n};\nfunction createBaseCNETMsgTick() {\n    return {\n        tick: 0,\n        hostComputationtime: 0,\n        hostComputationtimeStdDeviation: 0,\n        hostFramestarttimeStdDeviation: 0,\n        hltvReplayFlags: 0\n    };\n}\nexports.CNETMsgTick = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.tick !== 0) {\n            writer.uint32(8).uint32(message.tick);\n        }\n        if (message.hostComputationtime !== 0) {\n            writer.uint32(32).uint32(message.hostComputationtime);\n        }\n        if (message.hostComputationtimeStdDeviation !== 0) {\n            writer.uint32(40).uint32(message.hostComputationtimeStdDeviation);\n        }\n        if (message.hostFramestarttimeStdDeviation !== 0) {\n            writer.uint32(48).uint32(message.hostFramestarttimeStdDeviation);\n        }\n        if (message.hltvReplayFlags !== 0) {\n            writer.uint32(56).uint32(message.hltvReplayFlags);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCNETMsgTick();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.tick = reader.uint32();\n                    break;\n                case 4:\n                    message.hostComputationtime = reader.uint32();\n                    break;\n                case 5:\n                    message.hostComputationtimeStdDeviation = reader.uint32();\n                    break;\n                case 6:\n                    message.hostFramestarttimeStdDeviation = reader.uint32();\n                    break;\n                case 7:\n                    message.hltvReplayFlags = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseCNETMsgTick();\n        message.tick = (_a = object.tick) !== null && _a !== void 0 ? _a : 0;\n        message.hostComputationtime = (_b = object.hostComputationtime) !== null && _b !== void 0 ? _b : 0;\n        message.hostComputationtimeStdDeviation =\n            (_c = object.hostComputationtimeStdDeviation) !== null && _c !== void 0 ? _c : 0;\n        message.hostFramestarttimeStdDeviation =\n            (_d = object.hostFramestarttimeStdDeviation) !== null && _d !== void 0 ? _d : 0;\n        message.hltvReplayFlags = (_e = object.hltvReplayFlags) !== null && _e !== void 0 ? _e : 0;\n        return message;\n    }\n};\nfunction createBaseCNETMsgStringCmd() {\n    return { command: \"\" };\n}\nexports.CNETMsgStringCmd = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.command !== \"\") {\n            writer.uint32(10).string(message.command);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCNETMsgStringCmd();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.command = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCNETMsgStringCmd();\n        message.command = (_a = object.command) !== null && _a !== void 0 ? _a : \"\";\n        return message;\n    }\n};\nfunction createBaseCNETMsgSignonState() {\n    return {\n        signonState: 0,\n        spawnCount: 0,\n        numServerPlayers: 0,\n        playersNetworkids: [],\n        mapName: \"\"\n    };\n}\nexports.CNETMsgSignonState = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.signonState !== 0) {\n            writer.uint32(8).uint32(message.signonState);\n        }\n        if (message.spawnCount !== 0) {\n            writer.uint32(16).uint32(message.spawnCount);\n        }\n        if (message.numServerPlayers !== 0) {\n            writer.uint32(24).uint32(message.numServerPlayers);\n        }\n        for (const v of message.playersNetworkids) {\n            writer.uint32(34).string(v);\n        }\n        if (message.mapName !== \"\") {\n            writer.uint32(42).string(message.mapName);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCNETMsgSignonState();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.signonState = reader.uint32();\n                    break;\n                case 2:\n                    message.spawnCount = reader.uint32();\n                    break;\n                case 3:\n                    message.numServerPlayers = reader.uint32();\n                    break;\n                case 4:\n                    message.playersNetworkids.push(reader.string());\n                    break;\n                case 5:\n                    message.mapName = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseCNETMsgSignonState();\n        message.signonState = (_a = object.signonState) !== null && _a !== void 0 ? _a : 0;\n        message.spawnCount = (_b = object.spawnCount) !== null && _b !== void 0 ? _b : 0;\n        message.numServerPlayers = (_c = object.numServerPlayers) !== null && _c !== void 0 ? _c : 0;\n        message.playersNetworkids = ((_d = object.playersNetworkids) === null || _d === void 0 ? void 0 : _d.map(e => e)) || [];\n        message.mapName = (_e = object.mapName) !== null && _e !== void 0 ? _e : \"\";\n        return message;\n    }\n};\nfunction createBaseCMsgCVars() {\n    return { cvars: [] };\n}\nexports.CMsgCVars = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.cvars) {\n            exports.CMsgCVars_CVar.encode(v, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgCVars();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.cvars.push(exports.CMsgCVars_CVar.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCMsgCVars();\n        message.cvars = ((_a = object.cvars) === null || _a === void 0 ? void 0 : _a.map(e => exports.CMsgCVars_CVar.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCMsgCVars_CVar() {\n    return { name: \"\", value: \"\", dictionaryName: 0 };\n}\nexports.CMsgCVars_CVar = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.name !== \"\") {\n            writer.uint32(10).string(message.name);\n        }\n        if (message.value !== \"\") {\n            writer.uint32(18).string(message.value);\n        }\n        if (message.dictionaryName !== 0) {\n            writer.uint32(24).uint32(message.dictionaryName);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCMsgCVars_CVar();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.name = reader.string();\n                    break;\n                case 2:\n                    message.value = reader.string();\n                    break;\n                case 3:\n                    message.dictionaryName = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCMsgCVars_CVar();\n        message.name = (_a = object.name) !== null && _a !== void 0 ? _a : \"\";\n        message.value = (_b = object.value) !== null && _b !== void 0 ? _b : \"\";\n        message.dictionaryName = (_c = object.dictionaryName) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseCNETMsgSetConVar() {\n    return { convars: undefined };\n}\nexports.CNETMsgSetConVar = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.convars !== undefined) {\n            exports.CMsgCVars.encode(message.convars, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCNETMsgSetConVar();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.convars = exports.CMsgCVars.decode(reader, reader.uint32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        const message = createBaseCNETMsgSetConVar();\n        message.convars =\n            object.convars !== undefined && object.convars !== null\n                ? exports.CMsgCVars.fromPartial(object.convars)\n                : undefined;\n        return message;\n    }\n};\nfunction createBaseCNETMsgNOP() {\n    return {};\n}\nexports.CNETMsgNOP = {\n    encode(_, writer = minimal_1.Writer.create()) {\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCNETMsgNOP();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(_) {\n        const message = createBaseCNETMsgNOP();\n        return message;\n    }\n};\nfunction createBaseCNETMsgDisconnect() {\n    return { text: \"\" };\n}\nexports.CNETMsgDisconnect = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.text !== \"\") {\n            writer.uint32(10).string(message.text);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCNETMsgDisconnect();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.text = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCNETMsgDisconnect();\n        message.text = (_a = object.text) !== null && _a !== void 0 ? _a : \"\";\n        return message;\n    }\n};\nfunction createBaseCNETMsgFile() {\n    return { transferId: 0, fileName: \"\", isReplayDemoFile: false, deny: false };\n}\nexports.CNETMsgFile = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.transferId !== 0) {\n            writer.uint32(8).int32(message.transferId);\n        }\n        if (message.fileName !== \"\") {\n            writer.uint32(18).string(message.fileName);\n        }\n        if (message.isReplayDemoFile === true) {\n            writer.uint32(24).bool(message.isReplayDemoFile);\n        }\n        if (message.deny === true) {\n            writer.uint32(32).bool(message.deny);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCNETMsgFile();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.transferId = reader.int32();\n                    break;\n                case 2:\n                    message.fileName = reader.string();\n                    break;\n                case 3:\n                    message.isReplayDemoFile = reader.bool();\n                    break;\n                case 4:\n                    message.deny = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCNETMsgFile();\n        message.transferId = (_a = object.transferId) !== null && _a !== void 0 ? _a : 0;\n        message.fileName = (_b = object.fileName) !== null && _b !== void 0 ? _b : \"\";\n        message.isReplayDemoFile = (_c = object.isReplayDemoFile) !== null && _c !== void 0 ? _c : false;\n        message.deny = (_d = object.deny) !== null && _d !== void 0 ? _d : false;\n        return message;\n    }\n};\nfunction createBaseCNETMsgSplitScreenUser() {\n    return { slot: 0 };\n}\nexports.CNETMsgSplitScreenUser = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.slot !== 0) {\n            writer.uint32(8).int32(message.slot);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCNETMsgSplitScreenUser();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.slot = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCNETMsgSplitScreenUser();\n        message.slot = (_a = object.slot) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCNETMsgPlayerAvatarData() {\n    return { accountid: 0, rgb: new Uint8Array() };\n}\nexports.CNETMsgPlayerAvatarData = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.accountid !== 0) {\n            writer.uint32(8).uint32(message.accountid);\n        }\n        if (message.rgb.length !== 0) {\n            writer.uint32(18).bytes(message.rgb);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCNETMsgPlayerAvatarData();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.accountid = reader.uint32();\n                    break;\n                case 2:\n                    message.rgb = reader.bytes();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCNETMsgPlayerAvatarData();\n        message.accountid = (_a = object.accountid) !== null && _a !== void 0 ? _a : 0;\n        message.rgb = (_b = object.rgb) !== null && _b !== void 0 ? _b : new Uint8Array();\n        return message;\n    }\n};\nfunction createBaseCCLCMsgClientInfo() {\n    return {\n        sendTableCrc: 0,\n        serverCount: 0,\n        isHltv: false,\n        isReplay: false,\n        friendsId: 0,\n        friendsName: \"\",\n        customFiles: []\n    };\n}\nexports.CCLCMsgClientInfo = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.sendTableCrc !== 0) {\n            writer.uint32(13).fixed32(message.sendTableCrc);\n        }\n        if (message.serverCount !== 0) {\n            writer.uint32(16).uint32(message.serverCount);\n        }\n        if (message.isHltv === true) {\n            writer.uint32(24).bool(message.isHltv);\n        }\n        if (message.isReplay === true) {\n            writer.uint32(32).bool(message.isReplay);\n        }\n        if (message.friendsId !== 0) {\n            writer.uint32(40).uint32(message.friendsId);\n        }\n        if (message.friendsName !== \"\") {\n            writer.uint32(50).string(message.friendsName);\n        }\n        writer.uint32(58).fork();\n        for (const v of message.customFiles) {\n            writer.fixed32(v);\n        }\n        writer.ldelim();\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCLCMsgClientInfo();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.sendTableCrc = reader.fixed32();\n                    break;\n                case 2:\n                    message.serverCount = reader.uint32();\n                    break;\n                case 3:\n                    message.isHltv = reader.bool();\n                    break;\n                case 4:\n                    message.isReplay = reader.bool();\n                    break;\n                case 5:\n                    message.friendsId = reader.uint32();\n                    break;\n                case 6:\n                    message.friendsName = reader.string();\n                    break;\n                case 7:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.customFiles.push(reader.fixed32());\n                        }\n                    }\n                    else {\n                        message.customFiles.push(reader.fixed32());\n                    }\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g;\n        const message = createBaseCCLCMsgClientInfo();\n        message.sendTableCrc = (_a = object.sendTableCrc) !== null && _a !== void 0 ? _a : 0;\n        message.serverCount = (_b = object.serverCount) !== null && _b !== void 0 ? _b : 0;\n        message.isHltv = (_c = object.isHltv) !== null && _c !== void 0 ? _c : false;\n        message.isReplay = (_d = object.isReplay) !== null && _d !== void 0 ? _d : false;\n        message.friendsId = (_e = object.friendsId) !== null && _e !== void 0 ? _e : 0;\n        message.friendsName = (_f = object.friendsName) !== null && _f !== void 0 ? _f : \"\";\n        message.customFiles = ((_g = object.customFiles) === null || _g === void 0 ? void 0 : _g.map(e => e)) || [];\n        return message;\n    }\n};\nfunction createBaseCCLCMsgMove() {\n    return { numBackupCommands: 0, numNewCommands: 0, data: new Uint8Array() };\n}\nexports.CCLCMsgMove = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.numBackupCommands !== 0) {\n            writer.uint32(8).uint32(message.numBackupCommands);\n        }\n        if (message.numNewCommands !== 0) {\n            writer.uint32(16).uint32(message.numNewCommands);\n        }\n        if (message.data.length !== 0) {\n            writer.uint32(26).bytes(message.data);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCLCMsgMove();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.numBackupCommands = reader.uint32();\n                    break;\n                case 2:\n                    message.numNewCommands = reader.uint32();\n                    break;\n                case 3:\n                    message.data = reader.bytes();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCCLCMsgMove();\n        message.numBackupCommands = (_a = object.numBackupCommands) !== null && _a !== void 0 ? _a : 0;\n        message.numNewCommands = (_b = object.numNewCommands) !== null && _b !== void 0 ? _b : 0;\n        message.data = (_c = object.data) !== null && _c !== void 0 ? _c : new Uint8Array();\n        return message;\n    }\n};\nfunction createBaseCCLCMsgVoiceData() {\n    return {\n        data: new Uint8Array(),\n        xuid: Long.UZERO,\n        format: 0,\n        sequenceBytes: 0,\n        sectionNumber: 0,\n        uncompressedSampleOffset: 0\n    };\n}\nexports.CCLCMsgVoiceData = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.data.length !== 0) {\n            writer.uint32(10).bytes(message.data);\n        }\n        if (!message.xuid.isZero()) {\n            writer.uint32(17).fixed64(message.xuid);\n        }\n        if (message.format !== 0) {\n            writer.uint32(24).int32(message.format);\n        }\n        if (message.sequenceBytes !== 0) {\n            writer.uint32(32).int32(message.sequenceBytes);\n        }\n        if (message.sectionNumber !== 0) {\n            writer.uint32(40).uint32(message.sectionNumber);\n        }\n        if (message.uncompressedSampleOffset !== 0) {\n            writer.uint32(48).uint32(message.uncompressedSampleOffset);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCLCMsgVoiceData();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.data = reader.bytes();\n                    break;\n                case 2:\n                    message.xuid = reader.fixed64();\n                    break;\n                case 3:\n                    message.format = reader.int32();\n                    break;\n                case 4:\n                    message.sequenceBytes = reader.int32();\n                    break;\n                case 5:\n                    message.sectionNumber = reader.uint32();\n                    break;\n                case 6:\n                    message.uncompressedSampleOffset = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseCCLCMsgVoiceData();\n        message.data = (_a = object.data) !== null && _a !== void 0 ? _a : new Uint8Array();\n        message.xuid =\n            object.xuid !== undefined && object.xuid !== null\n                ? Long.fromValue(object.xuid)\n                : Long.UZERO;\n        message.format = (_b = object.format) !== null && _b !== void 0 ? _b : 0;\n        message.sequenceBytes = (_c = object.sequenceBytes) !== null && _c !== void 0 ? _c : 0;\n        message.sectionNumber = (_d = object.sectionNumber) !== null && _d !== void 0 ? _d : 0;\n        message.uncompressedSampleOffset = (_e = object.uncompressedSampleOffset) !== null && _e !== void 0 ? _e : 0;\n        return message;\n    }\n};\nfunction createBaseCCLCMsgBaselineAck() {\n    return { baselineTick: 0, baselineNr: 0 };\n}\nexports.CCLCMsgBaselineAck = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.baselineTick !== 0) {\n            writer.uint32(8).int32(message.baselineTick);\n        }\n        if (message.baselineNr !== 0) {\n            writer.uint32(16).int32(message.baselineNr);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCLCMsgBaselineAck();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.baselineTick = reader.int32();\n                    break;\n                case 2:\n                    message.baselineNr = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCCLCMsgBaselineAck();\n        message.baselineTick = (_a = object.baselineTick) !== null && _a !== void 0 ? _a : 0;\n        message.baselineNr = (_b = object.baselineNr) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCCLCMsgListenEvents() {\n    return { eventMask: [] };\n}\nexports.CCLCMsgListenEvents = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        writer.uint32(10).fork();\n        for (const v of message.eventMask) {\n            writer.fixed32(v);\n        }\n        writer.ldelim();\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCLCMsgListenEvents();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    if ((tag & 7) === 2) {\n                        const end2 = reader.uint32() + reader.pos;\n                        while (reader.pos < end2) {\n                            message.eventMask.push(reader.fixed32());\n                        }\n                    }\n                    else {\n                        message.eventMask.push(reader.fixed32());\n                    }\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCLCMsgListenEvents();\n        message.eventMask = ((_a = object.eventMask) === null || _a === void 0 ? void 0 : _a.map(e => e)) || [];\n        return message;\n    }\n};\nfunction createBaseCCLCMsgRespondCvarValue() {\n    return { cookie: 0, statusCode: 0, name: \"\", value: \"\" };\n}\nexports.CCLCMsgRespondCvarValue = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.cookie !== 0) {\n            writer.uint32(8).int32(message.cookie);\n        }\n        if (message.statusCode !== 0) {\n            writer.uint32(16).int32(message.statusCode);\n        }\n        if (message.name !== \"\") {\n            writer.uint32(26).string(message.name);\n        }\n        if (message.value !== \"\") {\n            writer.uint32(34).string(message.value);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCLCMsgRespondCvarValue();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.cookie = reader.int32();\n                    break;\n                case 2:\n                    message.statusCode = reader.int32();\n                    break;\n                case 3:\n                    message.name = reader.string();\n                    break;\n                case 4:\n                    message.value = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCCLCMsgRespondCvarValue();\n        message.cookie = (_a = object.cookie) !== null && _a !== void 0 ? _a : 0;\n        message.statusCode = (_b = object.statusCode) !== null && _b !== void 0 ? _b : 0;\n        message.name = (_c = object.name) !== null && _c !== void 0 ? _c : \"\";\n        message.value = (_d = object.value) !== null && _d !== void 0 ? _d : \"\";\n        return message;\n    }\n};\nfunction createBaseCCLCMsgFileCRCCheck() {\n    return {\n        codePath: 0,\n        path: \"\",\n        codeFilename: 0,\n        filename: \"\",\n        fileFraction: 0,\n        md5: new Uint8Array(),\n        crc: 0,\n        fileHashType: 0,\n        fileLen: 0,\n        packFileId: 0,\n        packFileNumber: 0\n    };\n}\nexports.CCLCMsgFileCRCCheck = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.codePath !== 0) {\n            writer.uint32(8).int32(message.codePath);\n        }\n        if (message.path !== \"\") {\n            writer.uint32(18).string(message.path);\n        }\n        if (message.codeFilename !== 0) {\n            writer.uint32(24).int32(message.codeFilename);\n        }\n        if (message.filename !== \"\") {\n            writer.uint32(34).string(message.filename);\n        }\n        if (message.fileFraction !== 0) {\n            writer.uint32(40).int32(message.fileFraction);\n        }\n        if (message.md5.length !== 0) {\n            writer.uint32(50).bytes(message.md5);\n        }\n        if (message.crc !== 0) {\n            writer.uint32(56).uint32(message.crc);\n        }\n        if (message.fileHashType !== 0) {\n            writer.uint32(64).int32(message.fileHashType);\n        }\n        if (message.fileLen !== 0) {\n            writer.uint32(72).int32(message.fileLen);\n        }\n        if (message.packFileId !== 0) {\n            writer.uint32(80).int32(message.packFileId);\n        }\n        if (message.packFileNumber !== 0) {\n            writer.uint32(88).int32(message.packFileNumber);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCLCMsgFileCRCCheck();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.codePath = reader.int32();\n                    break;\n                case 2:\n                    message.path = reader.string();\n                    break;\n                case 3:\n                    message.codeFilename = reader.int32();\n                    break;\n                case 4:\n                    message.filename = reader.string();\n                    break;\n                case 5:\n                    message.fileFraction = reader.int32();\n                    break;\n                case 6:\n                    message.md5 = reader.bytes();\n                    break;\n                case 7:\n                    message.crc = reader.uint32();\n                    break;\n                case 8:\n                    message.fileHashType = reader.int32();\n                    break;\n                case 9:\n                    message.fileLen = reader.int32();\n                    break;\n                case 10:\n                    message.packFileId = reader.int32();\n                    break;\n                case 11:\n                    message.packFileNumber = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;\n        const message = createBaseCCLCMsgFileCRCCheck();\n        message.codePath = (_a = object.codePath) !== null && _a !== void 0 ? _a : 0;\n        message.path = (_b = object.path) !== null && _b !== void 0 ? _b : \"\";\n        message.codeFilename = (_c = object.codeFilename) !== null && _c !== void 0 ? _c : 0;\n        message.filename = (_d = object.filename) !== null && _d !== void 0 ? _d : \"\";\n        message.fileFraction = (_e = object.fileFraction) !== null && _e !== void 0 ? _e : 0;\n        message.md5 = (_f = object.md5) !== null && _f !== void 0 ? _f : new Uint8Array();\n        message.crc = (_g = object.crc) !== null && _g !== void 0 ? _g : 0;\n        message.fileHashType = (_h = object.fileHashType) !== null && _h !== void 0 ? _h : 0;\n        message.fileLen = (_j = object.fileLen) !== null && _j !== void 0 ? _j : 0;\n        message.packFileId = (_k = object.packFileId) !== null && _k !== void 0 ? _k : 0;\n        message.packFileNumber = (_l = object.packFileNumber) !== null && _l !== void 0 ? _l : 0;\n        return message;\n    }\n};\nfunction createBaseCCLCMsgLoadingProgress() {\n    return { progress: 0 };\n}\nexports.CCLCMsgLoadingProgress = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.progress !== 0) {\n            writer.uint32(8).int32(message.progress);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCLCMsgLoadingProgress();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.progress = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCLCMsgLoadingProgress();\n        message.progress = (_a = object.progress) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCCLCMsgSplitPlayerConnect() {\n    return { convars: undefined };\n}\nexports.CCLCMsgSplitPlayerConnect = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.convars !== undefined) {\n            exports.CMsgCVars.encode(message.convars, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCLCMsgSplitPlayerConnect();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.convars = exports.CMsgCVars.decode(reader, reader.uint32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        const message = createBaseCCLCMsgSplitPlayerConnect();\n        message.convars =\n            object.convars !== undefined && object.convars !== null\n                ? exports.CMsgCVars.fromPartial(object.convars)\n                : undefined;\n        return message;\n    }\n};\nfunction createBaseCCLCMsgCmdKeyValues() {\n    return { keyvalues: new Uint8Array() };\n}\nexports.CCLCMsgCmdKeyValues = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.keyvalues.length !== 0) {\n            writer.uint32(10).bytes(message.keyvalues);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCLCMsgCmdKeyValues();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.keyvalues = reader.bytes();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCCLCMsgCmdKeyValues();\n        message.keyvalues = (_a = object.keyvalues) !== null && _a !== void 0 ? _a : new Uint8Array();\n        return message;\n    }\n};\nfunction createBaseCSVCMsgServerInfo() {\n    return {\n        protocol: 0,\n        serverCount: 0,\n        isDedicated: false,\n        isOfficialValveServer: false,\n        isHltv: false,\n        isReplay: false,\n        isRedirectingToProxyRelay: false,\n        cOs: 0,\n        mapCrc: 0,\n        clientCrc: 0,\n        stringTableCrc: 0,\n        maxClients: 0,\n        maxClasses: 0,\n        playerSlot: 0,\n        tickInterval: 0,\n        gameDir: \"\",\n        mapName: \"\",\n        mapGroupName: \"\",\n        skyName: \"\",\n        hostName: \"\",\n        publicIp: 0,\n        ugcMapId: Long.UZERO\n    };\n}\nexports.CSVCMsgServerInfo = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.protocol !== 0) {\n            writer.uint32(8).int32(message.protocol);\n        }\n        if (message.serverCount !== 0) {\n            writer.uint32(16).int32(message.serverCount);\n        }\n        if (message.isDedicated === true) {\n            writer.uint32(24).bool(message.isDedicated);\n        }\n        if (message.isOfficialValveServer === true) {\n            writer.uint32(32).bool(message.isOfficialValveServer);\n        }\n        if (message.isHltv === true) {\n            writer.uint32(40).bool(message.isHltv);\n        }\n        if (message.isReplay === true) {\n            writer.uint32(48).bool(message.isReplay);\n        }\n        if (message.isRedirectingToProxyRelay === true) {\n            writer.uint32(168).bool(message.isRedirectingToProxyRelay);\n        }\n        if (message.cOs !== 0) {\n            writer.uint32(56).int32(message.cOs);\n        }\n        if (message.mapCrc !== 0) {\n            writer.uint32(69).fixed32(message.mapCrc);\n        }\n        if (message.clientCrc !== 0) {\n            writer.uint32(77).fixed32(message.clientCrc);\n        }\n        if (message.stringTableCrc !== 0) {\n            writer.uint32(85).fixed32(message.stringTableCrc);\n        }\n        if (message.maxClients !== 0) {\n            writer.uint32(88).int32(message.maxClients);\n        }\n        if (message.maxClasses !== 0) {\n            writer.uint32(96).int32(message.maxClasses);\n        }\n        if (message.playerSlot !== 0) {\n            writer.uint32(104).int32(message.playerSlot);\n        }\n        if (message.tickInterval !== 0) {\n            writer.uint32(117).float(message.tickInterval);\n        }\n        if (message.gameDir !== \"\") {\n            writer.uint32(122).string(message.gameDir);\n        }\n        if (message.mapName !== \"\") {\n            writer.uint32(130).string(message.mapName);\n        }\n        if (message.mapGroupName !== \"\") {\n            writer.uint32(138).string(message.mapGroupName);\n        }\n        if (message.skyName !== \"\") {\n            writer.uint32(146).string(message.skyName);\n        }\n        if (message.hostName !== \"\") {\n            writer.uint32(154).string(message.hostName);\n        }\n        if (message.publicIp !== 0) {\n            writer.uint32(160).uint32(message.publicIp);\n        }\n        if (!message.ugcMapId.isZero()) {\n            writer.uint32(176).uint64(message.ugcMapId);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgServerInfo();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.protocol = reader.int32();\n                    break;\n                case 2:\n                    message.serverCount = reader.int32();\n                    break;\n                case 3:\n                    message.isDedicated = reader.bool();\n                    break;\n                case 4:\n                    message.isOfficialValveServer = reader.bool();\n                    break;\n                case 5:\n                    message.isHltv = reader.bool();\n                    break;\n                case 6:\n                    message.isReplay = reader.bool();\n                    break;\n                case 21:\n                    message.isRedirectingToProxyRelay = reader.bool();\n                    break;\n                case 7:\n                    message.cOs = reader.int32();\n                    break;\n                case 8:\n                    message.mapCrc = reader.fixed32();\n                    break;\n                case 9:\n                    message.clientCrc = reader.fixed32();\n                    break;\n                case 10:\n                    message.stringTableCrc = reader.fixed32();\n                    break;\n                case 11:\n                    message.maxClients = reader.int32();\n                    break;\n                case 12:\n                    message.maxClasses = reader.int32();\n                    break;\n                case 13:\n                    message.playerSlot = reader.int32();\n                    break;\n                case 14:\n                    message.tickInterval = reader.float();\n                    break;\n                case 15:\n                    message.gameDir = reader.string();\n                    break;\n                case 16:\n                    message.mapName = reader.string();\n                    break;\n                case 17:\n                    message.mapGroupName = reader.string();\n                    break;\n                case 18:\n                    message.skyName = reader.string();\n                    break;\n                case 19:\n                    message.hostName = reader.string();\n                    break;\n                case 20:\n                    message.publicIp = reader.uint32();\n                    break;\n                case 22:\n                    message.ugcMapId = reader.uint64();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;\n        const message = createBaseCSVCMsgServerInfo();\n        message.protocol = (_a = object.protocol) !== null && _a !== void 0 ? _a : 0;\n        message.serverCount = (_b = object.serverCount) !== null && _b !== void 0 ? _b : 0;\n        message.isDedicated = (_c = object.isDedicated) !== null && _c !== void 0 ? _c : false;\n        message.isOfficialValveServer = (_d = object.isOfficialValveServer) !== null && _d !== void 0 ? _d : false;\n        message.isHltv = (_e = object.isHltv) !== null && _e !== void 0 ? _e : false;\n        message.isReplay = (_f = object.isReplay) !== null && _f !== void 0 ? _f : false;\n        message.isRedirectingToProxyRelay =\n            (_g = object.isRedirectingToProxyRelay) !== null && _g !== void 0 ? _g : false;\n        message.cOs = (_h = object.cOs) !== null && _h !== void 0 ? _h : 0;\n        message.mapCrc = (_j = object.mapCrc) !== null && _j !== void 0 ? _j : 0;\n        message.clientCrc = (_k = object.clientCrc) !== null && _k !== void 0 ? _k : 0;\n        message.stringTableCrc = (_l = object.stringTableCrc) !== null && _l !== void 0 ? _l : 0;\n        message.maxClients = (_m = object.maxClients) !== null && _m !== void 0 ? _m : 0;\n        message.maxClasses = (_o = object.maxClasses) !== null && _o !== void 0 ? _o : 0;\n        message.playerSlot = (_p = object.playerSlot) !== null && _p !== void 0 ? _p : 0;\n        message.tickInterval = (_q = object.tickInterval) !== null && _q !== void 0 ? _q : 0;\n        message.gameDir = (_r = object.gameDir) !== null && _r !== void 0 ? _r : \"\";\n        message.mapName = (_s = object.mapName) !== null && _s !== void 0 ? _s : \"\";\n        message.mapGroupName = (_t = object.mapGroupName) !== null && _t !== void 0 ? _t : \"\";\n        message.skyName = (_u = object.skyName) !== null && _u !== void 0 ? _u : \"\";\n        message.hostName = (_v = object.hostName) !== null && _v !== void 0 ? _v : \"\";\n        message.publicIp = (_w = object.publicIp) !== null && _w !== void 0 ? _w : 0;\n        message.ugcMapId =\n            object.ugcMapId !== undefined && object.ugcMapId !== null\n                ? Long.fromValue(object.ugcMapId)\n                : Long.UZERO;\n        return message;\n    }\n};\nfunction createBaseCSVCMsgClassInfo() {\n    return { createOnClient: false, classes: [] };\n}\nexports.CSVCMsgClassInfo = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.createOnClient === true) {\n            writer.uint32(8).bool(message.createOnClient);\n        }\n        for (const v of message.classes) {\n            exports.CSVCMsgClassInfo_classT.encode(v, writer.uint32(18).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgClassInfo();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.createOnClient = reader.bool();\n                    break;\n                case 2:\n                    message.classes.push(exports.CSVCMsgClassInfo_classT.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCSVCMsgClassInfo();\n        message.createOnClient = (_a = object.createOnClient) !== null && _a !== void 0 ? _a : false;\n        message.classes =\n            ((_b = object.classes) === null || _b === void 0 ? void 0 : _b.map(e => exports.CSVCMsgClassInfo_classT.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCSVCMsgClassInfo_classT() {\n    return { classId: 0, dataTableName: \"\", className: \"\" };\n}\nexports.CSVCMsgClassInfo_classT = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.classId !== 0) {\n            writer.uint32(8).int32(message.classId);\n        }\n        if (message.dataTableName !== \"\") {\n            writer.uint32(18).string(message.dataTableName);\n        }\n        if (message.className !== \"\") {\n            writer.uint32(26).string(message.className);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgClassInfo_classT();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.classId = reader.int32();\n                    break;\n                case 2:\n                    message.dataTableName = reader.string();\n                    break;\n                case 3:\n                    message.className = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCSVCMsgClassInfo_classT();\n        message.classId = (_a = object.classId) !== null && _a !== void 0 ? _a : 0;\n        message.dataTableName = (_b = object.dataTableName) !== null && _b !== void 0 ? _b : \"\";\n        message.className = (_c = object.className) !== null && _c !== void 0 ? _c : \"\";\n        return message;\n    }\n};\nfunction createBaseCSVCMsgSendTable() {\n    return { isEnd: false, netTableName: \"\", needsDecoder: false, props: [] };\n}\nexports.CSVCMsgSendTable = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.isEnd === true) {\n            writer.uint32(8).bool(message.isEnd);\n        }\n        if (message.netTableName !== \"\") {\n            writer.uint32(18).string(message.netTableName);\n        }\n        if (message.needsDecoder === true) {\n            writer.uint32(24).bool(message.needsDecoder);\n        }\n        for (const v of message.props) {\n            exports.CSVCMsgSendTable_sendpropT.encode(v, writer.uint32(34).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgSendTable();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.isEnd = reader.bool();\n                    break;\n                case 2:\n                    message.netTableName = reader.string();\n                    break;\n                case 3:\n                    message.needsDecoder = reader.bool();\n                    break;\n                case 4:\n                    message.props.push(exports.CSVCMsgSendTable_sendpropT.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCSVCMsgSendTable();\n        message.isEnd = (_a = object.isEnd) !== null && _a !== void 0 ? _a : false;\n        message.netTableName = (_b = object.netTableName) !== null && _b !== void 0 ? _b : \"\";\n        message.needsDecoder = (_c = object.needsDecoder) !== null && _c !== void 0 ? _c : false;\n        message.props =\n            ((_d = object.props) === null || _d === void 0 ? void 0 : _d.map(e => exports.CSVCMsgSendTable_sendpropT.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCSVCMsgSendTable_sendpropT() {\n    return {\n        type: 0,\n        varName: \"\",\n        flags: 0,\n        priority: 0,\n        dtName: \"\",\n        numElements: 0,\n        lowValue: 0,\n        highValue: 0,\n        numBits: 0\n    };\n}\nexports.CSVCMsgSendTable_sendpropT = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.type !== 0) {\n            writer.uint32(8).int32(message.type);\n        }\n        if (message.varName !== \"\") {\n            writer.uint32(18).string(message.varName);\n        }\n        if (message.flags !== 0) {\n            writer.uint32(24).int32(message.flags);\n        }\n        if (message.priority !== 0) {\n            writer.uint32(32).int32(message.priority);\n        }\n        if (message.dtName !== \"\") {\n            writer.uint32(42).string(message.dtName);\n        }\n        if (message.numElements !== 0) {\n            writer.uint32(48).int32(message.numElements);\n        }\n        if (message.lowValue !== 0) {\n            writer.uint32(61).float(message.lowValue);\n        }\n        if (message.highValue !== 0) {\n            writer.uint32(69).float(message.highValue);\n        }\n        if (message.numBits !== 0) {\n            writer.uint32(72).int32(message.numBits);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgSendTable_sendpropT();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.type = reader.int32();\n                    break;\n                case 2:\n                    message.varName = reader.string();\n                    break;\n                case 3:\n                    message.flags = reader.int32();\n                    break;\n                case 4:\n                    message.priority = reader.int32();\n                    break;\n                case 5:\n                    message.dtName = reader.string();\n                    break;\n                case 6:\n                    message.numElements = reader.int32();\n                    break;\n                case 7:\n                    message.lowValue = reader.float();\n                    break;\n                case 8:\n                    message.highValue = reader.float();\n                    break;\n                case 9:\n                    message.numBits = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j;\n        const message = createBaseCSVCMsgSendTable_sendpropT();\n        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;\n        message.varName = (_b = object.varName) !== null && _b !== void 0 ? _b : \"\";\n        message.flags = (_c = object.flags) !== null && _c !== void 0 ? _c : 0;\n        message.priority = (_d = object.priority) !== null && _d !== void 0 ? _d : 0;\n        message.dtName = (_e = object.dtName) !== null && _e !== void 0 ? _e : \"\";\n        message.numElements = (_f = object.numElements) !== null && _f !== void 0 ? _f : 0;\n        message.lowValue = (_g = object.lowValue) !== null && _g !== void 0 ? _g : 0;\n        message.highValue = (_h = object.highValue) !== null && _h !== void 0 ? _h : 0;\n        message.numBits = (_j = object.numBits) !== null && _j !== void 0 ? _j : 0;\n        return message;\n    }\n};\nfunction createBaseCSVCMsgPrint() {\n    return { text: \"\" };\n}\nexports.CSVCMsgPrint = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.text !== \"\") {\n            writer.uint32(10).string(message.text);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgPrint();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.text = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCSVCMsgPrint();\n        message.text = (_a = object.text) !== null && _a !== void 0 ? _a : \"\";\n        return message;\n    }\n};\nfunction createBaseCSVCMsgSetPause() {\n    return { paused: false };\n}\nexports.CSVCMsgSetPause = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.paused === true) {\n            writer.uint32(8).bool(message.paused);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgSetPause();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.paused = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCSVCMsgSetPause();\n        message.paused = (_a = object.paused) !== null && _a !== void 0 ? _a : false;\n        return message;\n    }\n};\nfunction createBaseCSVCMsgSetView() {\n    return { entityIndex: 0 };\n}\nexports.CSVCMsgSetView = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.entityIndex !== 0) {\n            writer.uint32(8).int32(message.entityIndex);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgSetView();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.entityIndex = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCSVCMsgSetView();\n        message.entityIndex = (_a = object.entityIndex) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCSVCMsgCreateStringTable() {\n    return {\n        name: \"\",\n        maxEntries: 0,\n        numEntries: 0,\n        userDataFixedSize: false,\n        userDataSize: 0,\n        userDataSizeBits: 0,\n        flags: 0,\n        stringData: new Uint8Array()\n    };\n}\nexports.CSVCMsgCreateStringTable = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.name !== \"\") {\n            writer.uint32(10).string(message.name);\n        }\n        if (message.maxEntries !== 0) {\n            writer.uint32(16).int32(message.maxEntries);\n        }\n        if (message.numEntries !== 0) {\n            writer.uint32(24).int32(message.numEntries);\n        }\n        if (message.userDataFixedSize === true) {\n            writer.uint32(32).bool(message.userDataFixedSize);\n        }\n        if (message.userDataSize !== 0) {\n            writer.uint32(40).int32(message.userDataSize);\n        }\n        if (message.userDataSizeBits !== 0) {\n            writer.uint32(48).int32(message.userDataSizeBits);\n        }\n        if (message.flags !== 0) {\n            writer.uint32(56).int32(message.flags);\n        }\n        if (message.stringData.length !== 0) {\n            writer.uint32(66).bytes(message.stringData);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgCreateStringTable();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.name = reader.string();\n                    break;\n                case 2:\n                    message.maxEntries = reader.int32();\n                    break;\n                case 3:\n                    message.numEntries = reader.int32();\n                    break;\n                case 4:\n                    message.userDataFixedSize = reader.bool();\n                    break;\n                case 5:\n                    message.userDataSize = reader.int32();\n                    break;\n                case 6:\n                    message.userDataSizeBits = reader.int32();\n                    break;\n                case 7:\n                    message.flags = reader.int32();\n                    break;\n                case 8:\n                    message.stringData = reader.bytes();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h;\n        const message = createBaseCSVCMsgCreateStringTable();\n        message.name = (_a = object.name) !== null && _a !== void 0 ? _a : \"\";\n        message.maxEntries = (_b = object.maxEntries) !== null && _b !== void 0 ? _b : 0;\n        message.numEntries = (_c = object.numEntries) !== null && _c !== void 0 ? _c : 0;\n        message.userDataFixedSize = (_d = object.userDataFixedSize) !== null && _d !== void 0 ? _d : false;\n        message.userDataSize = (_e = object.userDataSize) !== null && _e !== void 0 ? _e : 0;\n        message.userDataSizeBits = (_f = object.userDataSizeBits) !== null && _f !== void 0 ? _f : 0;\n        message.flags = (_g = object.flags) !== null && _g !== void 0 ? _g : 0;\n        message.stringData = (_h = object.stringData) !== null && _h !== void 0 ? _h : new Uint8Array();\n        return message;\n    }\n};\nfunction createBaseCSVCMsgUpdateStringTable() {\n    return { tableId: 0, numChangedEntries: 0, stringData: new Uint8Array() };\n}\nexports.CSVCMsgUpdateStringTable = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.tableId !== 0) {\n            writer.uint32(8).int32(message.tableId);\n        }\n        if (message.numChangedEntries !== 0) {\n            writer.uint32(16).int32(message.numChangedEntries);\n        }\n        if (message.stringData.length !== 0) {\n            writer.uint32(26).bytes(message.stringData);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgUpdateStringTable();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.tableId = reader.int32();\n                    break;\n                case 2:\n                    message.numChangedEntries = reader.int32();\n                    break;\n                case 3:\n                    message.stringData = reader.bytes();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCSVCMsgUpdateStringTable();\n        message.tableId = (_a = object.tableId) !== null && _a !== void 0 ? _a : 0;\n        message.numChangedEntries = (_b = object.numChangedEntries) !== null && _b !== void 0 ? _b : 0;\n        message.stringData = (_c = object.stringData) !== null && _c !== void 0 ? _c : new Uint8Array();\n        return message;\n    }\n};\nfunction createBaseCSVCMsgVoiceInit() {\n    return { quality: 0, codec: \"\", version: 0 };\n}\nexports.CSVCMsgVoiceInit = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.quality !== 0) {\n            writer.uint32(8).int32(message.quality);\n        }\n        if (message.codec !== \"\") {\n            writer.uint32(18).string(message.codec);\n        }\n        if (message.version !== 0) {\n            writer.uint32(24).int32(message.version);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgVoiceInit();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.quality = reader.int32();\n                    break;\n                case 2:\n                    message.codec = reader.string();\n                    break;\n                case 3:\n                    message.version = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCSVCMsgVoiceInit();\n        message.quality = (_a = object.quality) !== null && _a !== void 0 ? _a : 0;\n        message.codec = (_b = object.codec) !== null && _b !== void 0 ? _b : \"\";\n        message.version = (_c = object.version) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseCSVCMsgVoiceData() {\n    return {\n        client: 0,\n        proximity: false,\n        xuid: Long.UZERO,\n        audibleMask: 0,\n        voiceData: new Uint8Array(),\n        caster: false,\n        format: 0,\n        sequenceBytes: 0,\n        sectionNumber: 0,\n        uncompressedSampleOffset: 0\n    };\n}\nexports.CSVCMsgVoiceData = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.client !== 0) {\n            writer.uint32(8).int32(message.client);\n        }\n        if (message.proximity === true) {\n            writer.uint32(16).bool(message.proximity);\n        }\n        if (!message.xuid.isZero()) {\n            writer.uint32(25).fixed64(message.xuid);\n        }\n        if (message.audibleMask !== 0) {\n            writer.uint32(32).int32(message.audibleMask);\n        }\n        if (message.voiceData.length !== 0) {\n            writer.uint32(42).bytes(message.voiceData);\n        }\n        if (message.caster === true) {\n            writer.uint32(48).bool(message.caster);\n        }\n        if (message.format !== 0) {\n            writer.uint32(56).int32(message.format);\n        }\n        if (message.sequenceBytes !== 0) {\n            writer.uint32(64).int32(message.sequenceBytes);\n        }\n        if (message.sectionNumber !== 0) {\n            writer.uint32(72).uint32(message.sectionNumber);\n        }\n        if (message.uncompressedSampleOffset !== 0) {\n            writer.uint32(80).uint32(message.uncompressedSampleOffset);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgVoiceData();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.client = reader.int32();\n                    break;\n                case 2:\n                    message.proximity = reader.bool();\n                    break;\n                case 3:\n                    message.xuid = reader.fixed64();\n                    break;\n                case 4:\n                    message.audibleMask = reader.int32();\n                    break;\n                case 5:\n                    message.voiceData = reader.bytes();\n                    break;\n                case 6:\n                    message.caster = reader.bool();\n                    break;\n                case 7:\n                    message.format = reader.int32();\n                    break;\n                case 8:\n                    message.sequenceBytes = reader.int32();\n                    break;\n                case 9:\n                    message.sectionNumber = reader.uint32();\n                    break;\n                case 10:\n                    message.uncompressedSampleOffset = reader.uint32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j;\n        const message = createBaseCSVCMsgVoiceData();\n        message.client = (_a = object.client) !== null && _a !== void 0 ? _a : 0;\n        message.proximity = (_b = object.proximity) !== null && _b !== void 0 ? _b : false;\n        message.xuid =\n            object.xuid !== undefined && object.xuid !== null\n                ? Long.fromValue(object.xuid)\n                : Long.UZERO;\n        message.audibleMask = (_c = object.audibleMask) !== null && _c !== void 0 ? _c : 0;\n        message.voiceData = (_d = object.voiceData) !== null && _d !== void 0 ? _d : new Uint8Array();\n        message.caster = (_e = object.caster) !== null && _e !== void 0 ? _e : false;\n        message.format = (_f = object.format) !== null && _f !== void 0 ? _f : 0;\n        message.sequenceBytes = (_g = object.sequenceBytes) !== null && _g !== void 0 ? _g : 0;\n        message.sectionNumber = (_h = object.sectionNumber) !== null && _h !== void 0 ? _h : 0;\n        message.uncompressedSampleOffset = (_j = object.uncompressedSampleOffset) !== null && _j !== void 0 ? _j : 0;\n        return message;\n    }\n};\nfunction createBaseCSVCMsgFixAngle() {\n    return { relative: false, angle: undefined };\n}\nexports.CSVCMsgFixAngle = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.relative === true) {\n            writer.uint32(8).bool(message.relative);\n        }\n        if (message.angle !== undefined) {\n            exports.CMsgQAngle.encode(message.angle, writer.uint32(18).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgFixAngle();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.relative = reader.bool();\n                    break;\n                case 2:\n                    message.angle = exports.CMsgQAngle.decode(reader, reader.uint32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCSVCMsgFixAngle();\n        message.relative = (_a = object.relative) !== null && _a !== void 0 ? _a : false;\n        message.angle =\n            object.angle !== undefined && object.angle !== null\n                ? exports.CMsgQAngle.fromPartial(object.angle)\n                : undefined;\n        return message;\n    }\n};\nfunction createBaseCSVCMsgCrosshairAngle() {\n    return { angle: undefined };\n}\nexports.CSVCMsgCrosshairAngle = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.angle !== undefined) {\n            exports.CMsgQAngle.encode(message.angle, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgCrosshairAngle();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.angle = exports.CMsgQAngle.decode(reader, reader.uint32());\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        const message = createBaseCSVCMsgCrosshairAngle();\n        message.angle =\n            object.angle !== undefined && object.angle !== null\n                ? exports.CMsgQAngle.fromPartial(object.angle)\n                : undefined;\n        return message;\n    }\n};\nfunction createBaseCSVCMsgPrefetch() {\n    return { soundIndex: 0 };\n}\nexports.CSVCMsgPrefetch = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.soundIndex !== 0) {\n            writer.uint32(8).int32(message.soundIndex);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgPrefetch();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.soundIndex = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCSVCMsgPrefetch();\n        message.soundIndex = (_a = object.soundIndex) !== null && _a !== void 0 ? _a : 0;\n        return message;\n    }\n};\nfunction createBaseCSVCMsgBSPDecal() {\n    return {\n        pos: undefined,\n        decalTextureIndex: 0,\n        entityIndex: 0,\n        modelIndex: 0,\n        lowPriority: false\n    };\n}\nexports.CSVCMsgBSPDecal = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.pos !== undefined) {\n            exports.CMsgVector.encode(message.pos, writer.uint32(10).fork()).ldelim();\n        }\n        if (message.decalTextureIndex !== 0) {\n            writer.uint32(16).int32(message.decalTextureIndex);\n        }\n        if (message.entityIndex !== 0) {\n            writer.uint32(24).int32(message.entityIndex);\n        }\n        if (message.modelIndex !== 0) {\n            writer.uint32(32).int32(message.modelIndex);\n        }\n        if (message.lowPriority === true) {\n            writer.uint32(40).bool(message.lowPriority);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgBSPDecal();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.pos = exports.CMsgVector.decode(reader, reader.uint32());\n                    break;\n                case 2:\n                    message.decalTextureIndex = reader.int32();\n                    break;\n                case 3:\n                    message.entityIndex = reader.int32();\n                    break;\n                case 4:\n                    message.modelIndex = reader.int32();\n                    break;\n                case 5:\n                    message.lowPriority = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCSVCMsgBSPDecal();\n        message.pos =\n            object.pos !== undefined && object.pos !== null\n                ? exports.CMsgVector.fromPartial(object.pos)\n                : undefined;\n        message.decalTextureIndex = (_a = object.decalTextureIndex) !== null && _a !== void 0 ? _a : 0;\n        message.entityIndex = (_b = object.entityIndex) !== null && _b !== void 0 ? _b : 0;\n        message.modelIndex = (_c = object.modelIndex) !== null && _c !== void 0 ? _c : 0;\n        message.lowPriority = (_d = object.lowPriority) !== null && _d !== void 0 ? _d : false;\n        return message;\n    }\n};\nfunction createBaseCSVCMsgSplitScreen() {\n    return { type: 0, slot: 0, playerIndex: 0 };\n}\nexports.CSVCMsgSplitScreen = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.type !== 0) {\n            writer.uint32(8).int32(message.type);\n        }\n        if (message.slot !== 0) {\n            writer.uint32(16).int32(message.slot);\n        }\n        if (message.playerIndex !== 0) {\n            writer.uint32(24).int32(message.playerIndex);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgSplitScreen();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.type = reader.int32();\n                    break;\n                case 2:\n                    message.slot = reader.int32();\n                    break;\n                case 3:\n                    message.playerIndex = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCSVCMsgSplitScreen();\n        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;\n        message.slot = (_b = object.slot) !== null && _b !== void 0 ? _b : 0;\n        message.playerIndex = (_c = object.playerIndex) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseCSVCMsgGetCvarValue() {\n    return { cookie: 0, cvarName: \"\" };\n}\nexports.CSVCMsgGetCvarValue = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.cookie !== 0) {\n            writer.uint32(8).int32(message.cookie);\n        }\n        if (message.cvarName !== \"\") {\n            writer.uint32(18).string(message.cvarName);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgGetCvarValue();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.cookie = reader.int32();\n                    break;\n                case 2:\n                    message.cvarName = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCSVCMsgGetCvarValue();\n        message.cookie = (_a = object.cookie) !== null && _a !== void 0 ? _a : 0;\n        message.cvarName = (_b = object.cvarName) !== null && _b !== void 0 ? _b : \"\";\n        return message;\n    }\n};\nfunction createBaseCSVCMsgMenu() {\n    return { dialogType: 0, menuKeyValues: new Uint8Array() };\n}\nexports.CSVCMsgMenu = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.dialogType !== 0) {\n            writer.uint32(8).int32(message.dialogType);\n        }\n        if (message.menuKeyValues.length !== 0) {\n            writer.uint32(18).bytes(message.menuKeyValues);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgMenu();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.dialogType = reader.int32();\n                    break;\n                case 2:\n                    message.menuKeyValues = reader.bytes();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCSVCMsgMenu();\n        message.dialogType = (_a = object.dialogType) !== null && _a !== void 0 ? _a : 0;\n        message.menuKeyValues = (_b = object.menuKeyValues) !== null && _b !== void 0 ? _b : new Uint8Array();\n        return message;\n    }\n};\nfunction createBaseCSVCMsgUserMessage() {\n    return { msgType: 0, msgData: new Uint8Array(), passthrough: 0 };\n}\nexports.CSVCMsgUserMessage = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.msgType !== 0) {\n            writer.uint32(8).int32(message.msgType);\n        }\n        if (message.msgData.length !== 0) {\n            writer.uint32(18).bytes(message.msgData);\n        }\n        if (message.passthrough !== 0) {\n            writer.uint32(24).int32(message.passthrough);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgUserMessage();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.msgType = reader.int32();\n                    break;\n                case 2:\n                    message.msgData = reader.bytes();\n                    break;\n                case 3:\n                    message.passthrough = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCSVCMsgUserMessage();\n        message.msgType = (_a = object.msgType) !== null && _a !== void 0 ? _a : 0;\n        message.msgData = (_b = object.msgData) !== null && _b !== void 0 ? _b : new Uint8Array();\n        message.passthrough = (_c = object.passthrough) !== null && _c !== void 0 ? _c : 0;\n        return message;\n    }\n};\nfunction createBaseCSVCMsgPaintmapData() {\n    return { paintmap: new Uint8Array() };\n}\nexports.CSVCMsgPaintmapData = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.paintmap.length !== 0) {\n            writer.uint32(10).bytes(message.paintmap);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgPaintmapData();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.paintmap = reader.bytes();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCSVCMsgPaintmapData();\n        message.paintmap = (_a = object.paintmap) !== null && _a !== void 0 ? _a : new Uint8Array();\n        return message;\n    }\n};\nfunction createBaseCSVCMsgGameEvent() {\n    return { eventName: \"\", eventid: 0, keys: [], passthrough: 0 };\n}\nexports.CSVCMsgGameEvent = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.eventName !== \"\") {\n            writer.uint32(10).string(message.eventName);\n        }\n        if (message.eventid !== 0) {\n            writer.uint32(16).int32(message.eventid);\n        }\n        for (const v of message.keys) {\n            exports.CSVCMsgGameEvent_keyT.encode(v, writer.uint32(26).fork()).ldelim();\n        }\n        if (message.passthrough !== 0) {\n            writer.uint32(32).int32(message.passthrough);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgGameEvent();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.eventName = reader.string();\n                    break;\n                case 2:\n                    message.eventid = reader.int32();\n                    break;\n                case 3:\n                    message.keys.push(exports.CSVCMsgGameEvent_keyT.decode(reader, reader.uint32()));\n                    break;\n                case 4:\n                    message.passthrough = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d;\n        const message = createBaseCSVCMsgGameEvent();\n        message.eventName = (_a = object.eventName) !== null && _a !== void 0 ? _a : \"\";\n        message.eventid = (_b = object.eventid) !== null && _b !== void 0 ? _b : 0;\n        message.keys =\n            ((_c = object.keys) === null || _c === void 0 ? void 0 : _c.map(e => exports.CSVCMsgGameEvent_keyT.fromPartial(e))) || [];\n        message.passthrough = (_d = object.passthrough) !== null && _d !== void 0 ? _d : 0;\n        return message;\n    }\n};\nfunction createBaseCSVCMsgGameEvent_keyT() {\n    return {\n        type: 0,\n        valString: \"\",\n        valFloat: 0,\n        valLong: 0,\n        valShort: 0,\n        valByte: 0,\n        valBool: false,\n        valUint64: Long.UZERO,\n        valWstring: new Uint8Array()\n    };\n}\nexports.CSVCMsgGameEvent_keyT = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.type !== 0) {\n            writer.uint32(8).int32(message.type);\n        }\n        if (message.valString !== \"\") {\n            writer.uint32(18).string(message.valString);\n        }\n        if (message.valFloat !== 0) {\n            writer.uint32(29).float(message.valFloat);\n        }\n        if (message.valLong !== 0) {\n            writer.uint32(32).int32(message.valLong);\n        }\n        if (message.valShort !== 0) {\n            writer.uint32(40).int32(message.valShort);\n        }\n        if (message.valByte !== 0) {\n            writer.uint32(48).int32(message.valByte);\n        }\n        if (message.valBool === true) {\n            writer.uint32(56).bool(message.valBool);\n        }\n        if (!message.valUint64.isZero()) {\n            writer.uint32(64).uint64(message.valUint64);\n        }\n        if (message.valWstring.length !== 0) {\n            writer.uint32(74).bytes(message.valWstring);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgGameEvent_keyT();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.type = reader.int32();\n                    break;\n                case 2:\n                    message.valString = reader.string();\n                    break;\n                case 3:\n                    message.valFloat = reader.float();\n                    break;\n                case 4:\n                    message.valLong = reader.int32();\n                    break;\n                case 5:\n                    message.valShort = reader.int32();\n                    break;\n                case 6:\n                    message.valByte = reader.int32();\n                    break;\n                case 7:\n                    message.valBool = reader.bool();\n                    break;\n                case 8:\n                    message.valUint64 = reader.uint64();\n                    break;\n                case 9:\n                    message.valWstring = reader.bytes();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h;\n        const message = createBaseCSVCMsgGameEvent_keyT();\n        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;\n        message.valString = (_b = object.valString) !== null && _b !== void 0 ? _b : \"\";\n        message.valFloat = (_c = object.valFloat) !== null && _c !== void 0 ? _c : 0;\n        message.valLong = (_d = object.valLong) !== null && _d !== void 0 ? _d : 0;\n        message.valShort = (_e = object.valShort) !== null && _e !== void 0 ? _e : 0;\n        message.valByte = (_f = object.valByte) !== null && _f !== void 0 ? _f : 0;\n        message.valBool = (_g = object.valBool) !== null && _g !== void 0 ? _g : false;\n        message.valUint64 =\n            object.valUint64 !== undefined && object.valUint64 !== null\n                ? Long.fromValue(object.valUint64)\n                : Long.UZERO;\n        message.valWstring = (_h = object.valWstring) !== null && _h !== void 0 ? _h : new Uint8Array();\n        return message;\n    }\n};\nfunction createBaseCSVCMsgGameEventList() {\n    return { descriptors: [] };\n}\nexports.CSVCMsgGameEventList = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        for (const v of message.descriptors) {\n            exports.CSVCMsgGameEventList_descriptorT.encode(v, writer.uint32(10).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgGameEventList();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.descriptors.push(exports.CSVCMsgGameEventList_descriptorT.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCSVCMsgGameEventList();\n        message.descriptors =\n            ((_a = object.descriptors) === null || _a === void 0 ? void 0 : _a.map(e => exports.CSVCMsgGameEventList_descriptorT.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCSVCMsgGameEventList_keyT() {\n    return { type: 0, name: \"\" };\n}\nexports.CSVCMsgGameEventList_keyT = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.type !== 0) {\n            writer.uint32(8).int32(message.type);\n        }\n        if (message.name !== \"\") {\n            writer.uint32(18).string(message.name);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgGameEventList_keyT();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.type = reader.int32();\n                    break;\n                case 2:\n                    message.name = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCSVCMsgGameEventList_keyT();\n        message.type = (_a = object.type) !== null && _a !== void 0 ? _a : 0;\n        message.name = (_b = object.name) !== null && _b !== void 0 ? _b : \"\";\n        return message;\n    }\n};\nfunction createBaseCSVCMsgGameEventList_descriptorT() {\n    return { eventid: 0, name: \"\", keys: [] };\n}\nexports.CSVCMsgGameEventList_descriptorT = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.eventid !== 0) {\n            writer.uint32(8).int32(message.eventid);\n        }\n        if (message.name !== \"\") {\n            writer.uint32(18).string(message.name);\n        }\n        for (const v of message.keys) {\n            exports.CSVCMsgGameEventList_keyT.encode(v, writer.uint32(26).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgGameEventList_descriptorT();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.eventid = reader.int32();\n                    break;\n                case 2:\n                    message.name = reader.string();\n                    break;\n                case 3:\n                    message.keys.push(exports.CSVCMsgGameEventList_keyT.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCSVCMsgGameEventList_descriptorT();\n        message.eventid = (_a = object.eventid) !== null && _a !== void 0 ? _a : 0;\n        message.name = (_b = object.name) !== null && _b !== void 0 ? _b : \"\";\n        message.keys =\n            ((_c = object.keys) === null || _c === void 0 ? void 0 : _c.map(e => exports.CSVCMsgGameEventList_keyT.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCSVCMsgTempEntities() {\n    return { reliable: false, numEntries: 0, entityData: new Uint8Array() };\n}\nexports.CSVCMsgTempEntities = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.reliable === true) {\n            writer.uint32(8).bool(message.reliable);\n        }\n        if (message.numEntries !== 0) {\n            writer.uint32(16).int32(message.numEntries);\n        }\n        if (message.entityData.length !== 0) {\n            writer.uint32(26).bytes(message.entityData);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgTempEntities();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.reliable = reader.bool();\n                    break;\n                case 2:\n                    message.numEntries = reader.int32();\n                    break;\n                case 3:\n                    message.entityData = reader.bytes();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCSVCMsgTempEntities();\n        message.reliable = (_a = object.reliable) !== null && _a !== void 0 ? _a : false;\n        message.numEntries = (_b = object.numEntries) !== null && _b !== void 0 ? _b : 0;\n        message.entityData = (_c = object.entityData) !== null && _c !== void 0 ? _c : new Uint8Array();\n        return message;\n    }\n};\nfunction createBaseCSVCMsgPacketEntities() {\n    return {\n        maxEntries: 0,\n        updatedEntries: 0,\n        isDelta: false,\n        updateBaseline: false,\n        baseline: 0,\n        deltaFrom: 0,\n        entityData: new Uint8Array()\n    };\n}\nexports.CSVCMsgPacketEntities = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.maxEntries !== 0) {\n            writer.uint32(8).int32(message.maxEntries);\n        }\n        if (message.updatedEntries !== 0) {\n            writer.uint32(16).int32(message.updatedEntries);\n        }\n        if (message.isDelta === true) {\n            writer.uint32(24).bool(message.isDelta);\n        }\n        if (message.updateBaseline === true) {\n            writer.uint32(32).bool(message.updateBaseline);\n        }\n        if (message.baseline !== 0) {\n            writer.uint32(40).int32(message.baseline);\n        }\n        if (message.deltaFrom !== 0) {\n            writer.uint32(48).int32(message.deltaFrom);\n        }\n        if (message.entityData.length !== 0) {\n            writer.uint32(58).bytes(message.entityData);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgPacketEntities();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.maxEntries = reader.int32();\n                    break;\n                case 2:\n                    message.updatedEntries = reader.int32();\n                    break;\n                case 3:\n                    message.isDelta = reader.bool();\n                    break;\n                case 4:\n                    message.updateBaseline = reader.bool();\n                    break;\n                case 5:\n                    message.baseline = reader.int32();\n                    break;\n                case 6:\n                    message.deltaFrom = reader.int32();\n                    break;\n                case 7:\n                    message.entityData = reader.bytes();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g;\n        const message = createBaseCSVCMsgPacketEntities();\n        message.maxEntries = (_a = object.maxEntries) !== null && _a !== void 0 ? _a : 0;\n        message.updatedEntries = (_b = object.updatedEntries) !== null && _b !== void 0 ? _b : 0;\n        message.isDelta = (_c = object.isDelta) !== null && _c !== void 0 ? _c : false;\n        message.updateBaseline = (_d = object.updateBaseline) !== null && _d !== void 0 ? _d : false;\n        message.baseline = (_e = object.baseline) !== null && _e !== void 0 ? _e : 0;\n        message.deltaFrom = (_f = object.deltaFrom) !== null && _f !== void 0 ? _f : 0;\n        message.entityData = (_g = object.entityData) !== null && _g !== void 0 ? _g : new Uint8Array();\n        return message;\n    }\n};\nfunction createBaseCSVCMsgSounds() {\n    return { reliableSound: false, sounds: [] };\n}\nexports.CSVCMsgSounds = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.reliableSound === true) {\n            writer.uint32(8).bool(message.reliableSound);\n        }\n        for (const v of message.sounds) {\n            exports.CSVCMsgSounds_sounddataT.encode(v, writer.uint32(18).fork()).ldelim();\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgSounds();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.reliableSound = reader.bool();\n                    break;\n                case 2:\n                    message.sounds.push(exports.CSVCMsgSounds_sounddataT.decode(reader, reader.uint32()));\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCSVCMsgSounds();\n        message.reliableSound = (_a = object.reliableSound) !== null && _a !== void 0 ? _a : false;\n        message.sounds =\n            ((_b = object.sounds) === null || _b === void 0 ? void 0 : _b.map(e => exports.CSVCMsgSounds_sounddataT.fromPartial(e))) || [];\n        return message;\n    }\n};\nfunction createBaseCSVCMsgSounds_sounddataT() {\n    return {\n        originX: 0,\n        originY: 0,\n        originZ: 0,\n        volume: 0,\n        delayValue: 0,\n        sequenceNumber: 0,\n        entityIndex: 0,\n        channel: 0,\n        pitch: 0,\n        flags: 0,\n        soundNum: 0,\n        soundNumHandle: 0,\n        speakerEntity: 0,\n        randomSeed: 0,\n        soundLevel: 0,\n        isSentence: false,\n        isAmbient: false\n    };\n}\nexports.CSVCMsgSounds_sounddataT = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.originX !== 0) {\n            writer.uint32(8).sint32(message.originX);\n        }\n        if (message.originY !== 0) {\n            writer.uint32(16).sint32(message.originY);\n        }\n        if (message.originZ !== 0) {\n            writer.uint32(24).sint32(message.originZ);\n        }\n        if (message.volume !== 0) {\n            writer.uint32(32).uint32(message.volume);\n        }\n        if (message.delayValue !== 0) {\n            writer.uint32(45).float(message.delayValue);\n        }\n        if (message.sequenceNumber !== 0) {\n            writer.uint32(48).int32(message.sequenceNumber);\n        }\n        if (message.entityIndex !== 0) {\n            writer.uint32(56).int32(message.entityIndex);\n        }\n        if (message.channel !== 0) {\n            writer.uint32(64).int32(message.channel);\n        }\n        if (message.pitch !== 0) {\n            writer.uint32(72).int32(message.pitch);\n        }\n        if (message.flags !== 0) {\n            writer.uint32(80).int32(message.flags);\n        }\n        if (message.soundNum !== 0) {\n            writer.uint32(88).uint32(message.soundNum);\n        }\n        if (message.soundNumHandle !== 0) {\n            writer.uint32(101).fixed32(message.soundNumHandle);\n        }\n        if (message.speakerEntity !== 0) {\n            writer.uint32(104).int32(message.speakerEntity);\n        }\n        if (message.randomSeed !== 0) {\n            writer.uint32(112).int32(message.randomSeed);\n        }\n        if (message.soundLevel !== 0) {\n            writer.uint32(120).int32(message.soundLevel);\n        }\n        if (message.isSentence === true) {\n            writer.uint32(128).bool(message.isSentence);\n        }\n        if (message.isAmbient === true) {\n            writer.uint32(136).bool(message.isAmbient);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgSounds_sounddataT();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.originX = reader.sint32();\n                    break;\n                case 2:\n                    message.originY = reader.sint32();\n                    break;\n                case 3:\n                    message.originZ = reader.sint32();\n                    break;\n                case 4:\n                    message.volume = reader.uint32();\n                    break;\n                case 5:\n                    message.delayValue = reader.float();\n                    break;\n                case 6:\n                    message.sequenceNumber = reader.int32();\n                    break;\n                case 7:\n                    message.entityIndex = reader.int32();\n                    break;\n                case 8:\n                    message.channel = reader.int32();\n                    break;\n                case 9:\n                    message.pitch = reader.int32();\n                    break;\n                case 10:\n                    message.flags = reader.int32();\n                    break;\n                case 11:\n                    message.soundNum = reader.uint32();\n                    break;\n                case 12:\n                    message.soundNumHandle = reader.fixed32();\n                    break;\n                case 13:\n                    message.speakerEntity = reader.int32();\n                    break;\n                case 14:\n                    message.randomSeed = reader.int32();\n                    break;\n                case 15:\n                    message.soundLevel = reader.int32();\n                    break;\n                case 16:\n                    message.isSentence = reader.bool();\n                    break;\n                case 17:\n                    message.isAmbient = reader.bool();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;\n        const message = createBaseCSVCMsgSounds_sounddataT();\n        message.originX = (_a = object.originX) !== null && _a !== void 0 ? _a : 0;\n        message.originY = (_b = object.originY) !== null && _b !== void 0 ? _b : 0;\n        message.originZ = (_c = object.originZ) !== null && _c !== void 0 ? _c : 0;\n        message.volume = (_d = object.volume) !== null && _d !== void 0 ? _d : 0;\n        message.delayValue = (_e = object.delayValue) !== null && _e !== void 0 ? _e : 0;\n        message.sequenceNumber = (_f = object.sequenceNumber) !== null && _f !== void 0 ? _f : 0;\n        message.entityIndex = (_g = object.entityIndex) !== null && _g !== void 0 ? _g : 0;\n        message.channel = (_h = object.channel) !== null && _h !== void 0 ? _h : 0;\n        message.pitch = (_j = object.pitch) !== null && _j !== void 0 ? _j : 0;\n        message.flags = (_k = object.flags) !== null && _k !== void 0 ? _k : 0;\n        message.soundNum = (_l = object.soundNum) !== null && _l !== void 0 ? _l : 0;\n        message.soundNumHandle = (_m = object.soundNumHandle) !== null && _m !== void 0 ? _m : 0;\n        message.speakerEntity = (_o = object.speakerEntity) !== null && _o !== void 0 ? _o : 0;\n        message.randomSeed = (_p = object.randomSeed) !== null && _p !== void 0 ? _p : 0;\n        message.soundLevel = (_q = object.soundLevel) !== null && _q !== void 0 ? _q : 0;\n        message.isSentence = (_r = object.isSentence) !== null && _r !== void 0 ? _r : false;\n        message.isAmbient = (_s = object.isAmbient) !== null && _s !== void 0 ? _s : false;\n        return message;\n    }\n};\nfunction createBaseCSVCMsgEntityMsg() {\n    return { entIndex: 0, classId: 0, entData: new Uint8Array() };\n}\nexports.CSVCMsgEntityMsg = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.entIndex !== 0) {\n            writer.uint32(8).int32(message.entIndex);\n        }\n        if (message.classId !== 0) {\n            writer.uint32(16).int32(message.classId);\n        }\n        if (message.entData.length !== 0) {\n            writer.uint32(26).bytes(message.entData);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgEntityMsg();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.entIndex = reader.int32();\n                    break;\n                case 2:\n                    message.classId = reader.int32();\n                    break;\n                case 3:\n                    message.entData = reader.bytes();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c;\n        const message = createBaseCSVCMsgEntityMsg();\n        message.entIndex = (_a = object.entIndex) !== null && _a !== void 0 ? _a : 0;\n        message.classId = (_b = object.classId) !== null && _b !== void 0 ? _b : 0;\n        message.entData = (_c = object.entData) !== null && _c !== void 0 ? _c : new Uint8Array();\n        return message;\n    }\n};\nfunction createBaseCSVCMsgCmdKeyValues() {\n    return { keyvalues: new Uint8Array() };\n}\nexports.CSVCMsgCmdKeyValues = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.keyvalues.length !== 0) {\n            writer.uint32(10).bytes(message.keyvalues);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgCmdKeyValues();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.keyvalues = reader.bytes();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCSVCMsgCmdKeyValues();\n        message.keyvalues = (_a = object.keyvalues) !== null && _a !== void 0 ? _a : new Uint8Array();\n        return message;\n    }\n};\nfunction createBaseCSVCMsgEncryptedData() {\n    return { encrypted: new Uint8Array(), keyType: 0 };\n}\nexports.CSVCMsgEncryptedData = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.encrypted.length !== 0) {\n            writer.uint32(10).bytes(message.encrypted);\n        }\n        if (message.keyType !== 0) {\n            writer.uint32(16).int32(message.keyType);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgEncryptedData();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.encrypted = reader.bytes();\n                    break;\n                case 2:\n                    message.keyType = reader.int32();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b;\n        const message = createBaseCSVCMsgEncryptedData();\n        message.encrypted = (_a = object.encrypted) !== null && _a !== void 0 ? _a : new Uint8Array();\n        message.keyType = (_b = object.keyType) !== null && _b !== void 0 ? _b : 0;\n        return message;\n    }\n};\nfunction createBaseCSVCMsgHltvReplay() {\n    return {\n        delay: 0,\n        primaryTarget: 0,\n        replayStopAt: 0,\n        replayStartAt: 0,\n        replaySlowdownBegin: 0,\n        replaySlowdownEnd: 0,\n        replaySlowdownRate: 0\n    };\n}\nexports.CSVCMsgHltvReplay = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.delay !== 0) {\n            writer.uint32(8).int32(message.delay);\n        }\n        if (message.primaryTarget !== 0) {\n            writer.uint32(16).int32(message.primaryTarget);\n        }\n        if (message.replayStopAt !== 0) {\n            writer.uint32(24).int32(message.replayStopAt);\n        }\n        if (message.replayStartAt !== 0) {\n            writer.uint32(32).int32(message.replayStartAt);\n        }\n        if (message.replaySlowdownBegin !== 0) {\n            writer.uint32(40).int32(message.replaySlowdownBegin);\n        }\n        if (message.replaySlowdownEnd !== 0) {\n            writer.uint32(48).int32(message.replaySlowdownEnd);\n        }\n        if (message.replaySlowdownRate !== 0) {\n            writer.uint32(61).float(message.replaySlowdownRate);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgHltvReplay();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.delay = reader.int32();\n                    break;\n                case 2:\n                    message.primaryTarget = reader.int32();\n                    break;\n                case 3:\n                    message.replayStopAt = reader.int32();\n                    break;\n                case 4:\n                    message.replayStartAt = reader.int32();\n                    break;\n                case 5:\n                    message.replaySlowdownBegin = reader.int32();\n                    break;\n                case 6:\n                    message.replaySlowdownEnd = reader.int32();\n                    break;\n                case 7:\n                    message.replaySlowdownRate = reader.float();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e, _f, _g;\n        const message = createBaseCSVCMsgHltvReplay();\n        message.delay = (_a = object.delay) !== null && _a !== void 0 ? _a : 0;\n        message.primaryTarget = (_b = object.primaryTarget) !== null && _b !== void 0 ? _b : 0;\n        message.replayStopAt = (_c = object.replayStopAt) !== null && _c !== void 0 ? _c : 0;\n        message.replayStartAt = (_d = object.replayStartAt) !== null && _d !== void 0 ? _d : 0;\n        message.replaySlowdownBegin = (_e = object.replaySlowdownBegin) !== null && _e !== void 0 ? _e : 0;\n        message.replaySlowdownEnd = (_f = object.replaySlowdownEnd) !== null && _f !== void 0 ? _f : 0;\n        message.replaySlowdownRate = (_g = object.replaySlowdownRate) !== null && _g !== void 0 ? _g : 0;\n        return message;\n    }\n};\nfunction createBaseCCLCMsgHltvReplay() {\n    return {\n        request: 0,\n        slowdownLength: 0,\n        slowdownRate: 0,\n        primaryTargetEntIndex: 0,\n        eventTime: 0\n    };\n}\nexports.CCLCMsgHltvReplay = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.request !== 0) {\n            writer.uint32(8).int32(message.request);\n        }\n        if (message.slowdownLength !== 0) {\n            writer.uint32(21).float(message.slowdownLength);\n        }\n        if (message.slowdownRate !== 0) {\n            writer.uint32(29).float(message.slowdownRate);\n        }\n        if (message.primaryTargetEntIndex !== 0) {\n            writer.uint32(32).int32(message.primaryTargetEntIndex);\n        }\n        if (message.eventTime !== 0) {\n            writer.uint32(45).float(message.eventTime);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCCLCMsgHltvReplay();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.request = reader.int32();\n                    break;\n                case 2:\n                    message.slowdownLength = reader.float();\n                    break;\n                case 3:\n                    message.slowdownRate = reader.float();\n                    break;\n                case 4:\n                    message.primaryTargetEntIndex = reader.int32();\n                    break;\n                case 5:\n                    message.eventTime = reader.float();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a, _b, _c, _d, _e;\n        const message = createBaseCCLCMsgHltvReplay();\n        message.request = (_a = object.request) !== null && _a !== void 0 ? _a : 0;\n        message.slowdownLength = (_b = object.slowdownLength) !== null && _b !== void 0 ? _b : 0;\n        message.slowdownRate = (_c = object.slowdownRate) !== null && _c !== void 0 ? _c : 0;\n        message.primaryTargetEntIndex = (_d = object.primaryTargetEntIndex) !== null && _d !== void 0 ? _d : 0;\n        message.eventTime = (_e = object.eventTime) !== null && _e !== void 0 ? _e : 0;\n        return message;\n    }\n};\nfunction createBaseCSVCMsgBroadcastCommand() {\n    return { cmd: \"\" };\n}\nexports.CSVCMsgBroadcastCommand = {\n    encode(message, writer = minimal_1.Writer.create()) {\n        if (message.cmd !== \"\") {\n            writer.uint32(10).string(message.cmd);\n        }\n        return writer;\n    },\n    decode(input, length) {\n        const reader = input instanceof minimal_1.Reader ? input : new minimal_1.Reader(input);\n        let end = length === undefined ? reader.len : reader.pos + length;\n        const message = createBaseCSVCMsgBroadcastCommand();\n        while (reader.pos < end) {\n            const tag = reader.uint32();\n            switch (tag >>> 3) {\n                case 1:\n                    message.cmd = reader.string();\n                    break;\n                default:\n                    reader.skipType(tag & 7);\n                    break;\n            }\n        }\n        return message;\n    },\n    fromPartial(object) {\n        var _a;\n        const message = createBaseCSVCMsgBroadcastCommand();\n        message.cmd = (_a = object.cmd) !== null && _a !== void 0 ? _a : \"\";\n        return message;\n    }\n};\n// If you get a compile-error about 'Constructor<Long> and ... have no overlap',\n// add '--ts_proto_opt=esModuleInterop=true' as a flag when calling 'protoc'.\nif (minimal_1.util.Long !== Long) {\n    minimal_1.util.Long = Long;\n    (0, minimal_1.configure)();\n}\n//# sourceMappingURL=netmessages.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.decodeShareCode = void 0;\nconst bigInt = require(\"big-integer\");\nconst DICTIONARY = \"ABCDEFGHJKLMNOPQRSTUVWXYZabcdefhijkmnopqrstuvwxyz23456789\";\nfunction decodeShareCode(shareCode) {\n    if (!/^CSGO(-[\\w]{5}){5}$/.exec(shareCode))\n        throw new Error(`invalid share code: ${shareCode}`);\n    const code = shareCode.substring(5).replace(/-/g, \"\");\n    let big = bigInt.zero;\n    for (let i = code.length - 1; i >= 0; --i) {\n        big = big.multiply(DICTIONARY.length).plus(DICTIONARY.indexOf(code[i]));\n    }\n    const array = big.toArray(256).value;\n    if (array.length === 18) {\n        array.unshift(0);\n    }\n    return array;\n}\nexports.decodeShareCode = decodeShareCode;\n//# sourceMappingURL=sharecode.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.StringTables = void 0;\nconst assert = require(\"assert\");\nconst ByteBuffer = require(\"bytebuffer\");\nconst events_1 = require(\"events\");\nconst Long = require(\"long\");\nconst assert_exists_1 = require(\"./assert-exists\");\nconst consts = require(\"./consts\");\nconst consts_1 = require(\"./consts\");\nconst bitbuffer_1 = require(\"./ext/bitbuffer\");\nfunction parseUserInfoData(buf) {\n    const bytebuf = ByteBuffer.wrap(buf, ByteBuffer.BIG_ENDIAN);\n    bytebuf.skip(8);\n    const hi = bytebuf.readUint32();\n    const lo = bytebuf.readUint32();\n    const xuid = Long.fromBits(lo, hi);\n    const name = bytebuf\n        .readString(consts_1.MAX_PLAYER_NAME_LENGTH, ByteBuffer.METRICS_BYTES)\n        .split(\"\\0\", 2)[0];\n    const userId = bytebuf.readUint32();\n    const guid = bytebuf\n        .readString(consts_1.SIGNED_GUID_LEN + 1, ByteBuffer.METRICS_BYTES)\n        .split(\"\\0\", 2)[0];\n    bytebuf.skip(3);\n    const friendsId = bytebuf.readUint32();\n    const friendsName = bytebuf\n        .readString(consts_1.MAX_PLAYER_NAME_LENGTH, ByteBuffer.METRICS_BYTES)\n        .split(\"\\0\", 2)[0];\n    const fakePlayer = bytebuf.readByte() !== 0;\n    bytebuf.skip(3);\n    const isHltv = bytebuf.readByte() !== 0;\n    bytebuf.skip(3);\n    return {\n        xuid,\n        name,\n        userId,\n        guid,\n        friendsId,\n        friendsName,\n        fakePlayer,\n        isHltv\n    };\n}\n/**\n * Handles string tables for a demo file.\n */\nclass StringTables extends events_1.EventEmitter {\n    constructor() {\n        super();\n        this.tables = [];\n        /**\n         * User data handlers. Transform raw buffer into any other value.\n         * By default, `userinfo` user data is transformed to {@link PlayerInfo}\n         * objects.\n         */\n        this.userDataCallbacks = {\n            userinfo: parseUserInfoData\n        };\n    }\n    listen(messageEvents) {\n        messageEvents.on(\"svc_UpdateStringTable\", this._handleUpdateStringTable.bind(this));\n        messageEvents.on(\"svc_CreateStringTable\", this._handleCreateStringTable.bind(this));\n    }\n    findTableByName(name) {\n        return this.tables.find(table => table.name === name);\n    }\n    handleStringTables(bitbuf) {\n        const numTables = bitbuf.readUInt8();\n        for (let i = 0; i < numTables; ++i) {\n            const tableName = bitbuf.readCString();\n            this._handleStringTable(tableName, bitbuf);\n        }\n    }\n    _handleStringTable(name, bitbuf) {\n        var _a;\n        const userDataCallback = this.userDataCallbacks[name];\n        const table = (0, assert_exists_1.default)(this.findTableByName(name));\n        const numEntries = bitbuf.readUInt16();\n        for (let entryIndex = 0; entryIndex < numEntries; ++entryIndex) {\n            const entry = bitbuf.readCString();\n            let userData = null;\n            // has user data?\n            if (bitbuf.readOneBit()) {\n                const userDataSize = bitbuf.readUInt16();\n                const userDataBuf = bitbuf.readBytes(userDataSize);\n                userData =\n                    userDataCallback === undefined\n                        ? userDataBuf\n                        : userDataCallback(userDataBuf);\n            }\n            const oldUserData = (_a = table.entries[entryIndex]) === null || _a === void 0 ? void 0 : _a.userData;\n            table.entries[entryIndex] = { entry, userData };\n            this.emit(\"update\", {\n                table,\n                entryIndex,\n                entry,\n                userData,\n                oldUserData\n            });\n        }\n        // parse client-side entries\n        if (bitbuf.readOneBit()) {\n            const numStrings = bitbuf.readUInt16();\n            for (let i = 0; i < numStrings; ++i) {\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                const entry = bitbuf.readCString();\n                let userData = null;\n                if (bitbuf.readOneBit()) {\n                    const userDataSize = bitbuf.readUInt16();\n                    const userDataBuf = bitbuf.readBytes(userDataSize);\n                    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n                    userData =\n                        userDataCallback === undefined\n                            ? userDataBuf\n                            : userDataCallback(userDataBuf);\n                }\n                // TODO: do something with client-side entries\n            }\n        }\n        // table is ready\n        this.emit(\"postcreate\", table);\n    }\n    _parseStringTableUpdate(bitbuf, table, entries) {\n        const history = [];\n        const entryBits = Math.ceil(Math.log2(table.maxEntries));\n        const userDataCallback = this.userDataCallbacks[table.name];\n        assert(!bitbuf.readOneBit(), \"dictionary encoding unsupported\");\n        let entryIndex = -1;\n        for (let i = 0; i < entries; ++i) {\n            entryIndex += 1;\n            if (!bitbuf.readOneBit()) {\n                entryIndex = bitbuf.readUBits(entryBits);\n            }\n            assert(entryIndex >= 0 && entryIndex < table.maxEntries, \"bogus string index\");\n            const existingEntry = table.entries[entryIndex];\n            let entry = null;\n            // has the entry changed?\n            if (bitbuf.readOneBit()) {\n                // substring check\n                if (bitbuf.readOneBit()) {\n                    const index = bitbuf.readUBits(5);\n                    const bytesToCopy = bitbuf.readUBits(consts.SUBSTRING_BITS);\n                    const last = history[index];\n                    if (last == null) {\n                        throw new Error(\"string table entry is delta from non existent entry\");\n                    }\n                    const subStr = last.slice(0, bytesToCopy);\n                    const suffix = bitbuf.readCString();\n                    entry = subStr + suffix;\n                }\n                else {\n                    entry = bitbuf.readCString();\n                }\n            }\n            else {\n                // If the string itself hasn't changed, this entry must already exist\n                entry = (0, assert_exists_1.default)(existingEntry).entry;\n            }\n            // read in the user data\n            let userData = null;\n            if (bitbuf.readOneBit()) {\n                // don't read the length, it's fixed length and the length was networked down already\n                if (table.userDataFixedSize) {\n                    const userDataArray = [bitbuf.readUBits(table.userDataSizeBits)];\n                    userData = Buffer.from(userDataArray);\n                }\n                else {\n                    const bytes = bitbuf.readUBits(consts.MAX_USERDATA_BITS);\n                    userData = bitbuf.readBytes(bytes);\n                }\n                if (userDataCallback !== undefined) {\n                    userData = userDataCallback(userData);\n                }\n            }\n            else {\n                userData = existingEntry === null || existingEntry === void 0 ? void 0 : existingEntry.userData;\n            }\n            const oldUserData = existingEntry === null || existingEntry === void 0 ? void 0 : existingEntry.userData;\n            table.entries[entryIndex] = { entry, userData };\n            // add to history\n            if (history.length > 31) {\n                history.shift();\n            }\n            history.push(entry);\n            this.emit(\"update\", {\n                table,\n                entryIndex,\n                entry,\n                userData,\n                oldUserData\n            });\n        }\n    }\n    _handleCreateStringTable(msg) {\n        const bitbuf = bitbuffer_1.BitStream.from(msg.stringData);\n        // table shouldn't already exist\n        assert(this.findTableByName(msg.name) === undefined, \"table already exists\");\n        assert(msg.userDataSize === Math.ceil(msg.userDataSizeBits / 8), \"invalid user data byte size\");\n        assert(msg.userDataSizeBits <= 32, \"userdata value too large\");\n        // create an empty table\n        const table = {\n            name: msg.name,\n            entries: [],\n            userDataSizeBits: msg.userDataSizeBits,\n            userDataFixedSize: msg.userDataFixedSize,\n            maxEntries: msg.maxEntries\n        };\n        this.emit(\"create\", table);\n        this._parseStringTableUpdate(bitbuf, table, msg.numEntries);\n        this.tables.push(table);\n    }\n    _handleUpdateStringTable(msg) {\n        const bitbuf = bitbuffer_1.BitStream.from(msg.stringData);\n        const table = (0, assert_exists_1.default)(this.tables[msg.tableId], \"bad table index\");\n        this._parseStringTableUpdate(bitbuf, table, msg.numChangedEntries);\n    }\n}\nexports.StringTables = StringTables;\n//# sourceMappingURL=stringtables.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst assert = require(\"assert\");\nconst projectile_1 = require(\"../entities/projectile\");\nconst supplement = {\n    emits: [\"grenadeTrajectory\"],\n    setup: function grenadeTrajectory(demo) {\n        const trajectories = new Map();\n        function onEntityCreate(event) {\n            // We only care about grenade projectiles\n            if (!(event.entity instanceof projectile_1.Projectile))\n                return;\n            assert(!trajectories.has(event.entity.index));\n            trajectories.set(event.entity.index, [event.entity.position]);\n        }\n        function onEntityRemove(event) {\n            // If a projectile was thrown just before round end,\n            // it would be deleted before detonating.\n            trajectories.delete(event.index);\n        }\n        function onEntityChange(event) {\n            const index = event.entity.index;\n            if (!trajectories.has(index))\n                return;\n            const projectile = event.entity;\n            for (const change of event.changes) {\n                if (change.varName !== \"m_nBounces\")\n                    continue;\n                const oldValue = (change.oldValue || 0);\n                const newValue = change.newValue;\n                if (newValue > oldValue) {\n                    trajectories.get(index).push(projectile.position);\n                }\n            }\n        }\n        function onGrenadeDetonateEvent(event) {\n            const projectile = event.entity;\n            // todo: when could this be null?\n            const trajectory = trajectories.get(event.entityid);\n            trajectory.push(projectile.position);\n            demo.emit(\"grenadeTrajectory\", {\n                projectile,\n                thrower: event.player,\n                trajectory\n            });\n        }\n        function onMolotovDetonate({ projectile, thrower }) {\n            // todo: when could this be null?\n            const trajectory = trajectories.get(projectile.index);\n            trajectory.push(projectile.position);\n            demo.emit(\"grenadeTrajectory\", {\n                projectile,\n                thrower,\n                trajectory\n            });\n        }\n        demo.on(\"molotovDetonate\", onMolotovDetonate);\n        demo.entities.on(\"create\", onEntityCreate);\n        demo.entities.on(\"change\", onEntityChange);\n        demo.entities.on(\"remove\", onEntityRemove);\n        demo.gameEvents.on(\"decoy_detonate\", onGrenadeDetonateEvent);\n        demo.gameEvents.on(\"flashbang_detonate\", onGrenadeDetonateEvent);\n        demo.gameEvents.on(\"hegrenade_detonate\", onGrenadeDetonateEvent);\n        demo.gameEvents.on(\"smokegrenade_detonate\", onGrenadeDetonateEvent);\n        return () => {\n            demo.off(\"molotovDetonate\", onMolotovDetonate);\n            demo.entities.off(\"create\", onEntityCreate);\n            demo.entities.off(\"change\", onEntityChange);\n            demo.entities.off(\"remove\", onEntityRemove);\n            demo.gameEvents.off(\"decoy_detonate\", onGrenadeDetonateEvent);\n            demo.gameEvents.off(\"flashbang_detonate\", onGrenadeDetonateEvent);\n            demo.gameEvents.off(\"hegrenade_detonate\", onGrenadeDetonateEvent);\n            demo.gameEvents.off(\"smokegrenade_detonate\", onGrenadeDetonateEvent);\n        };\n    }\n};\nexports.default = supplement;\n//# sourceMappingURL=grenadetrajectory.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst player_1 = require(\"../entities/player\");\nconst itemdefs_1 = require(\"../entities/itemdefs\");\nconst equipmentIdMap = {\n    \"50\": \"Kevlar\",\n    \"51\": \"Assault Suit\",\n    \"55\": \"Defuser\"\n};\nconst supplement = {\n    emits: [\"itemPurchase\"],\n    setup: function purchase(demo) {\n        let pendingPurchases = [];\n        // Wait until tick end to find the entity.\n        // m_iWeaponPurchasesThisRound is always updated before the weapon entity is created.\n        function onTickEnd() {\n            for (const pending of pendingPurchases) {\n                // Some items won't have an entity representation, e.g. kevlar.\n                let weapon = pending.player.weapons.find(w => w.itemIndex === pending.weaponId);\n                // todo: why does molotov need remapping to incendiary?\n                if (!weapon && pending.weaponId === 46) {\n                    weapon = pending.player.weapons.find(w => w.itemIndex === 48);\n                }\n                demo.emit(\"itemPurchase\", { ...pending, weapon });\n            }\n            pendingPurchases = [];\n        }\n        function onEntityChange(e) {\n            var _a;\n            if (!(e.entity instanceof player_1.Player))\n                return;\n            // PERF: add ability to listen on specific tables\n            for (const change of e.changes) {\n                if (change.tableName !== \"m_iWeaponPurchasesThisRound\")\n                    continue;\n                const weaponId = parseInt(change.varName, 10);\n                const oldValue = (change.oldValue || 0);\n                const newValue = change.newValue;\n                const count = newValue - oldValue;\n                if (count > 0) {\n                    pendingPurchases.push({\n                        player: e.entity,\n                        weaponId,\n                        itemName: ((_a = itemdefs_1.itemDefinitionIndexMap[weaponId]) === null || _a === void 0 ? void 0 : _a.itemName) ||\n                            equipmentIdMap[weaponId] ||\n                            \"Unknown\",\n                        count,\n                        weapon: undefined\n                    });\n                }\n            }\n        }\n        demo.on(\"tickend\", onTickEnd);\n        demo.entities.on(\"change\", onEntityChange);\n        return () => {\n            demo.off(\"tickend\", onTickEnd);\n            demo.entities.off(\"change\", onEntityChange);\n        };\n    }\n};\nexports.default = supplement;\n//# sourceMappingURL=itempurchase.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst consts_1 = require(\"../consts\");\nconst molotovLoop = 1051353634; // murmurhash.v2(\"molotov.loop\", 1146049601)\nconst supplement = {\n    emits: [\"molotovDetonate\"],\n    setup: function molotovDetonate(demo) {\n        if (demo.currentTick >= 0) {\n            throw new Error(\"molotovDetonate event listeners must be added before parsing starts.\");\n        }\n        // Find the index of the fire loop sound.\n        // This is emitted when the grenade is thrown, and then stopped when it detonates.\n        let fireLoopSoundIndex = -1;\n        function onStringTableUpdate(e) {\n            if (e.table.name === \"soundprecache\") {\n                if (e.entry === \"weapons/molotov/fire_loop_1.wav\") {\n                    fireLoopSoundIndex = e.entryIndex;\n                }\n            }\n        }\n        // Cache the molotov projectile class.\n        // Note that this entity is shared between molotov and incendiary grenades.\n        let molotovProjectileClass = -1;\n        function onDataTablesReady() {\n            molotovProjectileClass = demo.entities.serverClasses.findIndex(sc => sc.name === \"CMolotovProjectile\");\n        }\n        function onSound(e) {\n            if (fireLoopSoundIndex < 0 || molotovProjectileClass < 0)\n                return;\n            for (const sound of e.sounds) {\n                // We only care about the fire loop sound\n                if (sound.soundNumHandle === 0) {\n                    if (sound.soundNum !== fireLoopSoundIndex)\n                        continue;\n                }\n                else {\n                    // todo: never actually see this\n                    if (sound.soundNumHandle !== molotovLoop)\n                        continue;\n                }\n                // The loop sound starts when the grenade is thrown,\n                // and is stopped on detonation.\n                if ((sound.flags & consts_1.SND_STOP) === 0)\n                    continue;\n                const projectile = demo.entities.entities.get(sound.entityIndex);\n                if (!projectile)\n                    continue;\n                // This sound is also stopped on the resulting inferno\n                // (i.e. the flames produced by a detonated fire grenade).\n                if (projectile.classId === molotovProjectileClass) {\n                    const thrower = projectile.owner;\n                    demo.emit(\"molotovDetonate\", {\n                        thrower,\n                        projectile\n                    });\n                }\n            }\n        }\n        demo.stringTables.on(\"update\", onStringTableUpdate);\n        demo.entities.on(\"datatablesready\", onDataTablesReady);\n        demo.on(\"svc_Sounds\", onSound);\n        return () => {\n            demo.stringTables.off(\"update\", onStringTableUpdate);\n            demo.entities.off(\"datatablesready\", onDataTablesReady);\n            demo.off(\"svc_Sounds\", onSound);\n        };\n    }\n};\nexports.default = supplement;\n//# sourceMappingURL=molotovdetonate.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.UserMessages = void 0;\nconst assert = require(\"assert\");\nconst events_1 = require(\"events\");\nconst usermessagetypes_1 = require(\"./usermessagetypes\");\n/**\n * Handles user messages for a demo file.\n */\nclass UserMessages extends events_1.EventEmitter {\n    listen(demo) {\n        demo.on(\"svc_UserMessage\", this._handleUserMessage.bind(this));\n    }\n    _handleUserMessage(msg) {\n        const um = usermessagetypes_1.userMessages[msg.msgType];\n        if (!um) {\n            return;\n        }\n        if (this.listenerCount(um.name) || this.listenerCount(\"message\")) {\n            const msgInst = um.class.decode(msg.msgData);\n            assert(msgInst, \"unable to decode user message\");\n            this.emit(um.name, msgInst);\n            this.emit(\"message\", {\n                name: um.name,\n                msg: msgInst\n            });\n        }\n    }\n}\nexports.UserMessages = UserMessages;\n//# sourceMappingURL=usermessages.js.map","\"use strict\";\n// DO NOT MODIFY!\n// Auto-generated by ./generators/usermessagetypes.ts\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.userMessages = void 0;\nconst um = require(\"./protobufs/cstrike15_usermessages\");\nexports.userMessages = [];\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_VGUIMenu] = {\n    name: \"VGUIMenu\",\n    class: um.CCSUsrMsgVGUIMenu\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_Geiger] = {\n    name: \"Geiger\",\n    class: um.CCSUsrMsgGeiger\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_Train] = {\n    name: \"Train\",\n    class: um.CCSUsrMsgTrain\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_HudText] = {\n    name: \"HudText\",\n    class: um.CCSUsrMsgHudText\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_SayText] = {\n    name: \"SayText\",\n    class: um.CCSUsrMsgSayText\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_SayText2] = {\n    name: \"SayText2\",\n    class: um.CCSUsrMsgSayText2\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_TextMsg] = {\n    name: \"TextMsg\",\n    class: um.CCSUsrMsgTextMsg\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_HudMsg] = {\n    name: \"HudMsg\",\n    class: um.CCSUsrMsgHudMsg\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_ResetHud] = {\n    name: \"ResetHud\",\n    class: um.CCSUsrMsgResetHud\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_GameTitle] = {\n    name: \"GameTitle\",\n    class: um.CCSUsrMsgGameTitle\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_Shake] = {\n    name: \"Shake\",\n    class: um.CCSUsrMsgShake\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_Fade] = {\n    name: \"Fade\",\n    class: um.CCSUsrMsgFade\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_Rumble] = {\n    name: \"Rumble\",\n    class: um.CCSUsrMsgRumble\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_CloseCaption] = {\n    name: \"CloseCaption\",\n    class: um.CCSUsrMsgCloseCaption\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_CloseCaptionDirect] = {\n    name: \"CloseCaptionDirect\",\n    class: um.CCSUsrMsgCloseCaptionDirect\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_SendAudio] = {\n    name: \"SendAudio\",\n    class: um.CCSUsrMsgSendAudio\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_RawAudio] = {\n    name: \"RawAudio\",\n    class: um.CCSUsrMsgRawAudio\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_VoiceMask] = {\n    name: \"VoiceMask\",\n    class: um.CCSUsrMsgVoiceMask\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_RequestState] = {\n    name: \"RequestState\",\n    class: um.CCSUsrMsgRequestState\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_Damage] = {\n    name: \"Damage\",\n    class: um.CCSUsrMsgDamage\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_RadioText] = {\n    name: \"RadioText\",\n    class: um.CCSUsrMsgRadioText\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_HintText] = {\n    name: \"HintText\",\n    class: um.CCSUsrMsgHintText\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_KeyHintText] = {\n    name: \"KeyHintText\",\n    class: um.CCSUsrMsgKeyHintText\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_ProcessSpottedEntityUpdate] = {\n    name: \"ProcessSpottedEntityUpdate\",\n    class: um.CCSUsrMsgProcessSpottedEntityUpdate\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_ReloadEffect] = {\n    name: \"ReloadEffect\",\n    class: um.CCSUsrMsgReloadEffect\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_AdjustMoney] = {\n    name: \"AdjustMoney\",\n    class: um.CCSUsrMsgAdjustMoney\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_StopSpectatorMode] = {\n    name: \"StopSpectatorMode\",\n    class: um.CCSUsrMsgStopSpectatorMode\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_KillCam] = {\n    name: \"KillCam\",\n    class: um.CCSUsrMsgKillCam\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_DesiredTimescale] = {\n    name: \"DesiredTimescale\",\n    class: um.CCSUsrMsgDesiredTimescale\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_CurrentTimescale] = {\n    name: \"CurrentTimescale\",\n    class: um.CCSUsrMsgCurrentTimescale\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_AchievementEvent] = {\n    name: \"AchievementEvent\",\n    class: um.CCSUsrMsgAchievementEvent\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_MatchEndConditions] = {\n    name: \"MatchEndConditions\",\n    class: um.CCSUsrMsgMatchEndConditions\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_DisconnectToLobby] = {\n    name: \"DisconnectToLobby\",\n    class: um.CCSUsrMsgDisconnectToLobby\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_PlayerStatsUpdate] = {\n    name: \"PlayerStatsUpdate\",\n    class: um.CCSUsrMsgPlayerStatsUpdate\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_DisplayInventory] = {\n    name: \"DisplayInventory\",\n    class: um.CCSUsrMsgDisplayInventory\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_WarmupHasEnded] = {\n    name: \"WarmupHasEnded\",\n    class: um.CCSUsrMsgWarmupHasEnded\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_ClientInfo] = {\n    name: \"ClientInfo\",\n    class: um.CCSUsrMsgClientInfo\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_XRankGet] = {\n    name: \"XRankGet\",\n    class: um.CCSUsrMsgXRankGet\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_XRankUpd] = {\n    name: \"XRankUpd\",\n    class: um.CCSUsrMsgXRankUpd\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_CallVoteFailed] = {\n    name: \"CallVoteFailed\",\n    class: um.CCSUsrMsgCallVoteFailed\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_VoteStart] = {\n    name: \"VoteStart\",\n    class: um.CCSUsrMsgVoteStart\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_VotePass] = {\n    name: \"VotePass\",\n    class: um.CCSUsrMsgVotePass\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_VoteFailed] = {\n    name: \"VoteFailed\",\n    class: um.CCSUsrMsgVoteFailed\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_VoteSetup] = {\n    name: \"VoteSetup\",\n    class: um.CCSUsrMsgVoteSetup\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_ServerRankRevealAll] = {\n    name: \"ServerRankRevealAll\",\n    class: um.CCSUsrMsgServerRankRevealAll\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_SendLastKillerDamageToClient] = {\n    name: \"SendLastKillerDamageToClient\",\n    class: um.CCSUsrMsgSendLastKillerDamageToClient\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_ServerRankUpdate] = {\n    name: \"ServerRankUpdate\",\n    class: um.CCSUsrMsgServerRankUpdate\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_ItemPickup] = {\n    name: \"ItemPickup\",\n    class: um.CCSUsrMsgItemPickup\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_ShowMenu] = {\n    name: \"ShowMenu\",\n    class: um.CCSUsrMsgShowMenu\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_BarTime] = {\n    name: \"BarTime\",\n    class: um.CCSUsrMsgBarTime\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_AmmoDenied] = {\n    name: \"AmmoDenied\",\n    class: um.CCSUsrMsgAmmoDenied\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_MarkAchievement] = {\n    name: \"MarkAchievement\",\n    class: um.CCSUsrMsgMarkAchievement\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_MatchStatsUpdate] = {\n    name: \"MatchStatsUpdate\",\n    class: um.CCSUsrMsgMatchStatsUpdate\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_ItemDrop] = {\n    name: \"ItemDrop\",\n    class: um.CCSUsrMsgItemDrop\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_GlowPropTurnOff] = {\n    name: \"GlowPropTurnOff\",\n    class: um.CCSUsrMsgGlowPropTurnOff\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_SendPlayerItemDrops] = {\n    name: \"SendPlayerItemDrops\",\n    class: um.CCSUsrMsgSendPlayerItemDrops\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_RoundBackupFilenames] = {\n    name: \"RoundBackupFilenames\",\n    class: um.CCSUsrMsgRoundBackupFilenames\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_SendPlayerItemFound] = {\n    name: \"SendPlayerItemFound\",\n    class: um.CCSUsrMsgSendPlayerItemFound\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_ReportHit] = {\n    name: \"ReportHit\",\n    class: um.CCSUsrMsgReportHit\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_XpUpdate] = {\n    name: \"XpUpdate\",\n    class: um.CCSUsrMsgXpUpdate\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_QuestProgress] = {\n    name: \"QuestProgress\",\n    class: um.CCSUsrMsgQuestProgress\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_ScoreLeaderboardData] = {\n    name: \"ScoreLeaderboardData\",\n    class: um.CCSUsrMsgScoreLeaderboardData\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_PlayerDecalDigitalSignature] = {\n    name: \"PlayerDecalDigitalSignature\",\n    class: um.CCSUsrMsgPlayerDecalDigitalSignature\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_WeaponSound] = {\n    name: \"WeaponSound\",\n    class: um.CCSUsrMsgWeaponSound\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_UpdateScreenHealthBar] = {\n    name: \"UpdateScreenHealthBar\",\n    class: um.CCSUsrMsgUpdateScreenHealthBar\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_EntityOutlineHighlight] = {\n    name: \"EntityOutlineHighlight\",\n    class: um.CCSUsrMsgEntityOutlineHighlight\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_SSUI] = {\n    name: \"SSUI\",\n    class: um.CCSUsrMsgSSUI\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_SurvivalStats] = {\n    name: \"SurvivalStats\",\n    class: um.CCSUsrMsgSurvivalStats\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_EndOfMatchAllPlayersData] = {\n    name: \"EndOfMatchAllPlayersData\",\n    class: um.CCSUsrMsgEndOfMatchAllPlayersData\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_RoundImpactScoreData] = {\n    name: \"RoundImpactScoreData\",\n    class: um.CCSUsrMsgRoundImpactScoreData\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_CurrentRoundOdds] = {\n    name: \"CurrentRoundOdds\",\n    class: um.CCSUsrMsgCurrentRoundOdds\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_DeepStats] = {\n    name: \"DeepStats\",\n    class: um.CCSUsrMsgDeepStats\n};\nexports.userMessages[um.ECstrike15UserMessages.CS_UM_UtilMsg] = {\n    name: \"UtilMsg\",\n    class: um.CCSUsrMsgUtilMsg\n};\n//# sourceMappingURL=usermessagetypes.js.map","var AwaitValue = require(\"./AwaitValue.js\");\n\nfunction AsyncGenerator(gen) {\n  var front, back;\n\n  function send(key, arg) {\n    return new Promise(function (resolve, reject) {\n      var request = {\n        key: key,\n        arg: arg,\n        resolve: resolve,\n        reject: reject,\n        next: null\n      };\n\n      if (back) {\n        back = back.next = request;\n      } else {\n        front = back = request;\n        resume(key, arg);\n      }\n    });\n  }\n\n  function resume(key, arg) {\n    try {\n      var result = gen[key](arg);\n      var value = result.value;\n      var wrappedAwait = value instanceof AwaitValue;\n      Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {\n        if (wrappedAwait) {\n          resume(key === \"return\" ? \"return\" : \"next\", arg);\n          return;\n        }\n\n        settle(result.done ? \"return\" : \"normal\", arg);\n      }, function (err) {\n        resume(\"throw\", err);\n      });\n    } catch (err) {\n      settle(\"throw\", err);\n    }\n  }\n\n  function settle(type, value) {\n    switch (type) {\n      case \"return\":\n        front.resolve({\n          value: value,\n          done: true\n        });\n        break;\n\n      case \"throw\":\n        front.reject(value);\n        break;\n\n      default:\n        front.resolve({\n          value: value,\n          done: false\n        });\n        break;\n    }\n\n    front = front.next;\n\n    if (front) {\n      resume(front.key, front.arg);\n    } else {\n      back = null;\n    }\n  }\n\n  this._invoke = send;\n\n  if (typeof gen[\"return\"] !== \"function\") {\n    this[\"return\"] = undefined;\n  }\n}\n\nAsyncGenerator.prototype[typeof Symbol === \"function\" && Symbol.asyncIterator || \"@@asyncIterator\"] = function () {\n  return this;\n};\n\nAsyncGenerator.prototype.next = function (arg) {\n  return this._invoke(\"next\", arg);\n};\n\nAsyncGenerator.prototype[\"throw\"] = function (arg) {\n  return this._invoke(\"throw\", arg);\n};\n\nAsyncGenerator.prototype[\"return\"] = function (arg) {\n  return this._invoke(\"return\", arg);\n};\n\nmodule.exports = AsyncGenerator, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _AwaitValue(value) {\n  this.wrapped = value;\n}\n\nmodule.exports = _AwaitValue, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}\n\nmodule.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\n\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\n\nmodule.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nmodule.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _asyncGeneratorDelegate(inner, awaitWrap) {\n  var iter = {},\n      waiting = false;\n\n  function pump(key, value) {\n    waiting = true;\n    value = new Promise(function (resolve) {\n      resolve(inner[key](value));\n    });\n    return {\n      done: false,\n      value: awaitWrap(value)\n    };\n  }\n\n  ;\n\n  iter[typeof Symbol !== \"undefined\" && Symbol.iterator || \"@@iterator\"] = function () {\n    return this;\n  };\n\n  iter.next = function (value) {\n    if (waiting) {\n      waiting = false;\n      return value;\n    }\n\n    return pump(\"next\", value);\n  };\n\n  if (typeof inner[\"throw\"] === \"function\") {\n    iter[\"throw\"] = function (value) {\n      if (waiting) {\n        waiting = false;\n        throw value;\n      }\n\n      return pump(\"throw\", value);\n    };\n  }\n\n  if (typeof inner[\"return\"] === \"function\") {\n    iter[\"return\"] = function (value) {\n      if (waiting) {\n        waiting = false;\n        return value;\n      }\n\n      return pump(\"return\", value);\n    };\n  }\n\n  return iter;\n}\n\nmodule.exports = _asyncGeneratorDelegate, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _asyncIterator(iterable) {\n  var method,\n      async,\n      sync,\n      retry = 2;\n\n  for (\"undefined\" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) {\n    if (async && null != (method = iterable[async])) return method.call(iterable);\n    if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));\n    async = \"@@asyncIterator\", sync = \"@@iterator\";\n  }\n\n  throw new TypeError(\"Object is not async iterable\");\n}\n\nfunction AsyncFromSyncIterator(s) {\n  function AsyncFromSyncIteratorContinuation(r) {\n    if (Object(r) !== r) return Promise.reject(new TypeError(r + \" is not an object.\"));\n    var done = r.done;\n    return Promise.resolve(r.value).then(function (value) {\n      return {\n        value: value,\n        done: done\n      };\n    });\n  }\n\n  return AsyncFromSyncIterator = function AsyncFromSyncIterator(s) {\n    this.s = s, this.n = s.next;\n  }, AsyncFromSyncIterator.prototype = {\n    s: null,\n    n: null,\n    next: function next() {\n      return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));\n    },\n    \"return\": function _return(value) {\n      var ret = this.s[\"return\"];\n      return void 0 === ret ? Promise.resolve({\n        value: value,\n        done: !0\n      }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));\n    },\n    \"throw\": function _throw(value) {\n      var thr = this.s[\"return\"];\n      return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));\n    }\n  }, new AsyncFromSyncIterator(s);\n}\n\nmodule.exports = _asyncIterator, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}\n\nmodule.exports = _asyncToGenerator, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var AwaitValue = require(\"./AwaitValue.js\");\n\nfunction _awaitAsyncGenerator(value) {\n  return new AwaitValue(value);\n}\n\nmodule.exports = _awaitAsyncGenerator, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nmodule.exports = _classCallCheck, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var setPrototypeOf = require(\"./setPrototypeOf.js\");\n\nvar isNativeReflectConstruct = require(\"./isNativeReflectConstruct.js\");\n\nfunction _construct(Parent, args, Class) {\n  if (isNativeReflectConstruct()) {\n    module.exports = _construct = Reflect.construct, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  } else {\n    module.exports = _construct = function _construct(Parent, args, Class) {\n      var a = [null];\n      a.push.apply(a, args);\n      var Constructor = Function.bind.apply(Parent, a);\n      var instance = new Constructor();\n      if (Class) setPrototypeOf(instance, Class.prototype);\n      return instance;\n    }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  }\n\n  return _construct.apply(null, arguments);\n}\n\nmodule.exports = _construct, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}\n\nmodule.exports = _createClass, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nmodule.exports = _defineProperty, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var superPropBase = require(\"./superPropBase.js\");\n\nfunction _get() {\n  if (typeof Reflect !== \"undefined\" && Reflect.get) {\n    module.exports = _get = Reflect.get, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  } else {\n    module.exports = _get = function _get(target, property, receiver) {\n      var base = superPropBase(target, property);\n      if (!base) return;\n      var desc = Object.getOwnPropertyDescriptor(base, property);\n\n      if (desc.get) {\n        return desc.get.call(arguments.length < 3 ? target : receiver);\n      }\n\n      return desc.value;\n    }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  }\n\n  return _get.apply(this, arguments);\n}\n\nmodule.exports = _get, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _getPrototypeOf(o) {\n  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  return _getPrototypeOf(o);\n}\n\nmodule.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var setPrototypeOf = require(\"./setPrototypeOf.js\");\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  Object.defineProperty(subClass, \"prototype\", {\n    writable: false\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}\n\nmodule.exports = _inherits, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n\n  try {\n    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\nmodule.exports = _isNativeReflectConstruct, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\n\nmodule.exports = _iterableToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _iterableToArrayLimit(arr, i) {\n  var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"];\n\n  if (_i == null) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n\n  var _s, _e;\n\n  try {\n    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}\n\nmodule.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableRest, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var _typeof = require(\"./typeof.js\")[\"default\"];\n\nvar assertThisInitialized = require(\"./assertThisInitialized.js\");\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  } else if (call !== void 0) {\n    throw new TypeError(\"Derived constructors may only return object or undefined\");\n  }\n\n  return assertThisInitialized(self);\n}\n\nmodule.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _setPrototypeOf(o, p) {\n  module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  return _setPrototypeOf(o, p);\n}\n\nmodule.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayWithHoles = require(\"./arrayWithHoles.js\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit.js\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\n\nvar nonIterableRest = require(\"./nonIterableRest.js\");\n\nfunction _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var getPrototypeOf = require(\"./getPrototypeOf.js\");\n\nfunction _superPropBase(object, property) {\n  while (!Object.prototype.hasOwnProperty.call(object, property)) {\n    object = getPrototypeOf(object);\n    if (object === null) break;\n  }\n\n  return object;\n}\n\nmodule.exports = _superPropBase, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayWithoutHoles = require(\"./arrayWithoutHoles.js\");\n\nvar iterableToArray = require(\"./iterableToArray.js\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\n\nvar nonIterableSpread = require(\"./nonIterableSpread.js\");\n\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\n\nmodule.exports = _toConsumableArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return (module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports), _typeof(obj);\n}\n\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}\n\nmodule.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var AsyncGenerator = require(\"./AsyncGenerator.js\");\n\nfunction _wrapAsyncGenerator(fn) {\n  return function () {\n    return new AsyncGenerator(fn.apply(this, arguments));\n  };\n}\n\nmodule.exports = _wrapAsyncGenerator, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","module.exports = require(\"regenerator-runtime\");\n","\"use strict\";\r\nmodule.exports = asPromise;\r\n\r\n/**\r\n * Callback as used by {@link util.asPromise}.\r\n * @typedef asPromiseCallback\r\n * @type {function}\r\n * @param {Error|null} error Error, if any\r\n * @param {...*} params Additional arguments\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Returns a promise from a node-style callback function.\r\n * @memberof util\r\n * @param {asPromiseCallback} fn Function to call\r\n * @param {*} ctx Function context\r\n * @param {...*} params Function arguments\r\n * @returns {Promise<*>} Promisified function\r\n */\r\nfunction asPromise(fn, ctx/*, varargs */) {\r\n    var params  = new Array(arguments.length - 1),\r\n        offset  = 0,\r\n        index   = 2,\r\n        pending = true;\r\n    while (index < arguments.length)\r\n        params[offset++] = arguments[index++];\r\n    return new Promise(function executor(resolve, reject) {\r\n        params[offset] = function callback(err/*, varargs */) {\r\n            if (pending) {\r\n                pending = false;\r\n                if (err)\r\n                    reject(err);\r\n                else {\r\n                    var params = new Array(arguments.length - 1),\r\n                        offset = 0;\r\n                    while (offset < params.length)\r\n                        params[offset++] = arguments[offset];\r\n                    resolve.apply(null, params);\r\n                }\r\n            }\r\n        };\r\n        try {\r\n            fn.apply(ctx || null, params);\r\n        } catch (err) {\r\n            if (pending) {\r\n                pending = false;\r\n                reject(err);\r\n            }\r\n        }\r\n    });\r\n}\r\n","\"use strict\";\r\n\r\n/**\r\n * A minimal base64 implementation for number arrays.\r\n * @memberof util\r\n * @namespace\r\n */\r\nvar base64 = exports;\r\n\r\n/**\r\n * Calculates the byte length of a base64 encoded string.\r\n * @param {string} string Base64 encoded string\r\n * @returns {number} Byte length\r\n */\r\nbase64.length = function length(string) {\r\n    var p = string.length;\r\n    if (!p)\r\n        return 0;\r\n    var n = 0;\r\n    while (--p % 4 > 1 && string.charAt(p) === \"=\")\r\n        ++n;\r\n    return Math.ceil(string.length * 3) / 4 - n;\r\n};\r\n\r\n// Base64 encoding table\r\nvar b64 = new Array(64);\r\n\r\n// Base64 decoding table\r\nvar s64 = new Array(123);\r\n\r\n// 65..90, 97..122, 48..57, 43, 47\r\nfor (var i = 0; i < 64;)\r\n    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;\r\n\r\n/**\r\n * Encodes a buffer to a base64 encoded string.\r\n * @param {Uint8Array} buffer Source buffer\r\n * @param {number} start Source start\r\n * @param {number} end Source end\r\n * @returns {string} Base64 encoded string\r\n */\r\nbase64.encode = function encode(buffer, start, end) {\r\n    var parts = null,\r\n        chunk = [];\r\n    var i = 0, // output index\r\n        j = 0, // goto index\r\n        t;     // temporary\r\n    while (start < end) {\r\n        var b = buffer[start++];\r\n        switch (j) {\r\n            case 0:\r\n                chunk[i++] = b64[b >> 2];\r\n                t = (b & 3) << 4;\r\n                j = 1;\r\n                break;\r\n            case 1:\r\n                chunk[i++] = b64[t | b >> 4];\r\n                t = (b & 15) << 2;\r\n                j = 2;\r\n                break;\r\n            case 2:\r\n                chunk[i++] = b64[t | b >> 6];\r\n                chunk[i++] = b64[b & 63];\r\n                j = 0;\r\n                break;\r\n        }\r\n        if (i > 8191) {\r\n            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));\r\n            i = 0;\r\n        }\r\n    }\r\n    if (j) {\r\n        chunk[i++] = b64[t];\r\n        chunk[i++] = 61;\r\n        if (j === 1)\r\n            chunk[i++] = 61;\r\n    }\r\n    if (parts) {\r\n        if (i)\r\n            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));\r\n        return parts.join(\"\");\r\n    }\r\n    return String.fromCharCode.apply(String, chunk.slice(0, i));\r\n};\r\n\r\nvar invalidEncoding = \"invalid encoding\";\r\n\r\n/**\r\n * Decodes a base64 encoded string to a buffer.\r\n * @param {string} string Source string\r\n * @param {Uint8Array} buffer Destination buffer\r\n * @param {number} offset Destination offset\r\n * @returns {number} Number of bytes written\r\n * @throws {Error} If encoding is invalid\r\n */\r\nbase64.decode = function decode(string, buffer, offset) {\r\n    var start = offset;\r\n    var j = 0, // goto index\r\n        t;     // temporary\r\n    for (var i = 0; i < string.length;) {\r\n        var c = string.charCodeAt(i++);\r\n        if (c === 61 && j > 1)\r\n            break;\r\n        if ((c = s64[c]) === undefined)\r\n            throw Error(invalidEncoding);\r\n        switch (j) {\r\n            case 0:\r\n                t = c;\r\n                j = 1;\r\n                break;\r\n            case 1:\r\n                buffer[offset++] = t << 2 | (c & 48) >> 4;\r\n                t = c;\r\n                j = 2;\r\n                break;\r\n            case 2:\r\n                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;\r\n                t = c;\r\n                j = 3;\r\n                break;\r\n            case 3:\r\n                buffer[offset++] = (t & 3) << 6 | c;\r\n                j = 0;\r\n                break;\r\n        }\r\n    }\r\n    if (j === 1)\r\n        throw Error(invalidEncoding);\r\n    return offset - start;\r\n};\r\n\r\n/**\r\n * Tests if the specified string appears to be base64 encoded.\r\n * @param {string} string String to test\r\n * @returns {boolean} `true` if probably base64 encoded, otherwise false\r\n */\r\nbase64.test = function test(string) {\r\n    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);\r\n};\r\n","\"use strict\";\r\nmodule.exports = EventEmitter;\r\n\r\n/**\r\n * Constructs a new event emitter instance.\r\n * @classdesc A minimal event emitter.\r\n * @memberof util\r\n * @constructor\r\n */\r\nfunction EventEmitter() {\r\n\r\n    /**\r\n     * Registered listeners.\r\n     * @type {Object.<string,*>}\r\n     * @private\r\n     */\r\n    this._listeners = {};\r\n}\r\n\r\n/**\r\n * Registers an event listener.\r\n * @param {string} evt Event name\r\n * @param {function} fn Listener\r\n * @param {*} [ctx] Listener context\r\n * @returns {util.EventEmitter} `this`\r\n */\r\nEventEmitter.prototype.on = function on(evt, fn, ctx) {\r\n    (this._listeners[evt] || (this._listeners[evt] = [])).push({\r\n        fn  : fn,\r\n        ctx : ctx || this\r\n    });\r\n    return this;\r\n};\r\n\r\n/**\r\n * Removes an event listener or any matching listeners if arguments are omitted.\r\n * @param {string} [evt] Event name. Removes all listeners if omitted.\r\n * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.\r\n * @returns {util.EventEmitter} `this`\r\n */\r\nEventEmitter.prototype.off = function off(evt, fn) {\r\n    if (evt === undefined)\r\n        this._listeners = {};\r\n    else {\r\n        if (fn === undefined)\r\n            this._listeners[evt] = [];\r\n        else {\r\n            var listeners = this._listeners[evt];\r\n            for (var i = 0; i < listeners.length;)\r\n                if (listeners[i].fn === fn)\r\n                    listeners.splice(i, 1);\r\n                else\r\n                    ++i;\r\n        }\r\n    }\r\n    return this;\r\n};\r\n\r\n/**\r\n * Emits an event by calling its listeners with the specified arguments.\r\n * @param {string} evt Event name\r\n * @param {...*} args Arguments\r\n * @returns {util.EventEmitter} `this`\r\n */\r\nEventEmitter.prototype.emit = function emit(evt) {\r\n    var listeners = this._listeners[evt];\r\n    if (listeners) {\r\n        var args = [],\r\n            i = 1;\r\n        for (; i < arguments.length;)\r\n            args.push(arguments[i++]);\r\n        for (i = 0; i < listeners.length;)\r\n            listeners[i].fn.apply(listeners[i++].ctx, args);\r\n    }\r\n    return this;\r\n};\r\n","\"use strict\";\r\n\r\nmodule.exports = factory(factory);\r\n\r\n/**\r\n * Reads / writes floats / doubles from / to buffers.\r\n * @name util.float\r\n * @namespace\r\n */\r\n\r\n/**\r\n * Writes a 32 bit float to a buffer using little endian byte order.\r\n * @name util.float.writeFloatLE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Writes a 32 bit float to a buffer using big endian byte order.\r\n * @name util.float.writeFloatBE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Reads a 32 bit float from a buffer using little endian byte order.\r\n * @name util.float.readFloatLE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n/**\r\n * Reads a 32 bit float from a buffer using big endian byte order.\r\n * @name util.float.readFloatBE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n/**\r\n * Writes a 64 bit double to a buffer using little endian byte order.\r\n * @name util.float.writeDoubleLE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Writes a 64 bit double to a buffer using big endian byte order.\r\n * @name util.float.writeDoubleBE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Reads a 64 bit double from a buffer using little endian byte order.\r\n * @name util.float.readDoubleLE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n/**\r\n * Reads a 64 bit double from a buffer using big endian byte order.\r\n * @name util.float.readDoubleBE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n// Factory function for the purpose of node-based testing in modified global environments\r\nfunction factory(exports) {\r\n\r\n    // float: typed array\r\n    if (typeof Float32Array !== \"undefined\") (function() {\r\n\r\n        var f32 = new Float32Array([ -0 ]),\r\n            f8b = new Uint8Array(f32.buffer),\r\n            le  = f8b[3] === 128;\r\n\r\n        function writeFloat_f32_cpy(val, buf, pos) {\r\n            f32[0] = val;\r\n            buf[pos    ] = f8b[0];\r\n            buf[pos + 1] = f8b[1];\r\n            buf[pos + 2] = f8b[2];\r\n            buf[pos + 3] = f8b[3];\r\n        }\r\n\r\n        function writeFloat_f32_rev(val, buf, pos) {\r\n            f32[0] = val;\r\n            buf[pos    ] = f8b[3];\r\n            buf[pos + 1] = f8b[2];\r\n            buf[pos + 2] = f8b[1];\r\n            buf[pos + 3] = f8b[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;\r\n        /* istanbul ignore next */\r\n        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;\r\n\r\n        function readFloat_f32_cpy(buf, pos) {\r\n            f8b[0] = buf[pos    ];\r\n            f8b[1] = buf[pos + 1];\r\n            f8b[2] = buf[pos + 2];\r\n            f8b[3] = buf[pos + 3];\r\n            return f32[0];\r\n        }\r\n\r\n        function readFloat_f32_rev(buf, pos) {\r\n            f8b[3] = buf[pos    ];\r\n            f8b[2] = buf[pos + 1];\r\n            f8b[1] = buf[pos + 2];\r\n            f8b[0] = buf[pos + 3];\r\n            return f32[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;\r\n        /* istanbul ignore next */\r\n        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;\r\n\r\n    // float: ieee754\r\n    })(); else (function() {\r\n\r\n        function writeFloat_ieee754(writeUint, val, buf, pos) {\r\n            var sign = val < 0 ? 1 : 0;\r\n            if (sign)\r\n                val = -val;\r\n            if (val === 0)\r\n                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);\r\n            else if (isNaN(val))\r\n                writeUint(2143289344, buf, pos);\r\n            else if (val > 3.4028234663852886e+38) // +-Infinity\r\n                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);\r\n            else if (val < 1.1754943508222875e-38) // denormal\r\n                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);\r\n            else {\r\n                var exponent = Math.floor(Math.log(val) / Math.LN2),\r\n                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;\r\n                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);\r\n            }\r\n        }\r\n\r\n        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);\r\n        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);\r\n\r\n        function readFloat_ieee754(readUint, buf, pos) {\r\n            var uint = readUint(buf, pos),\r\n                sign = (uint >> 31) * 2 + 1,\r\n                exponent = uint >>> 23 & 255,\r\n                mantissa = uint & 8388607;\r\n            return exponent === 255\r\n                ? mantissa\r\n                ? NaN\r\n                : sign * Infinity\r\n                : exponent === 0 // denormal\r\n                ? sign * 1.401298464324817e-45 * mantissa\r\n                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);\r\n        }\r\n\r\n        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);\r\n        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);\r\n\r\n    })();\r\n\r\n    // double: typed array\r\n    if (typeof Float64Array !== \"undefined\") (function() {\r\n\r\n        var f64 = new Float64Array([-0]),\r\n            f8b = new Uint8Array(f64.buffer),\r\n            le  = f8b[7] === 128;\r\n\r\n        function writeDouble_f64_cpy(val, buf, pos) {\r\n            f64[0] = val;\r\n            buf[pos    ] = f8b[0];\r\n            buf[pos + 1] = f8b[1];\r\n            buf[pos + 2] = f8b[2];\r\n            buf[pos + 3] = f8b[3];\r\n            buf[pos + 4] = f8b[4];\r\n            buf[pos + 5] = f8b[5];\r\n            buf[pos + 6] = f8b[6];\r\n            buf[pos + 7] = f8b[7];\r\n        }\r\n\r\n        function writeDouble_f64_rev(val, buf, pos) {\r\n            f64[0] = val;\r\n            buf[pos    ] = f8b[7];\r\n            buf[pos + 1] = f8b[6];\r\n            buf[pos + 2] = f8b[5];\r\n            buf[pos + 3] = f8b[4];\r\n            buf[pos + 4] = f8b[3];\r\n            buf[pos + 5] = f8b[2];\r\n            buf[pos + 6] = f8b[1];\r\n            buf[pos + 7] = f8b[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;\r\n        /* istanbul ignore next */\r\n        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;\r\n\r\n        function readDouble_f64_cpy(buf, pos) {\r\n            f8b[0] = buf[pos    ];\r\n            f8b[1] = buf[pos + 1];\r\n            f8b[2] = buf[pos + 2];\r\n            f8b[3] = buf[pos + 3];\r\n            f8b[4] = buf[pos + 4];\r\n            f8b[5] = buf[pos + 5];\r\n            f8b[6] = buf[pos + 6];\r\n            f8b[7] = buf[pos + 7];\r\n            return f64[0];\r\n        }\r\n\r\n        function readDouble_f64_rev(buf, pos) {\r\n            f8b[7] = buf[pos    ];\r\n            f8b[6] = buf[pos + 1];\r\n            f8b[5] = buf[pos + 2];\r\n            f8b[4] = buf[pos + 3];\r\n            f8b[3] = buf[pos + 4];\r\n            f8b[2] = buf[pos + 5];\r\n            f8b[1] = buf[pos + 6];\r\n            f8b[0] = buf[pos + 7];\r\n            return f64[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;\r\n        /* istanbul ignore next */\r\n        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;\r\n\r\n    // double: ieee754\r\n    })(); else (function() {\r\n\r\n        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {\r\n            var sign = val < 0 ? 1 : 0;\r\n            if (sign)\r\n                val = -val;\r\n            if (val === 0) {\r\n                writeUint(0, buf, pos + off0);\r\n                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);\r\n            } else if (isNaN(val)) {\r\n                writeUint(0, buf, pos + off0);\r\n                writeUint(2146959360, buf, pos + off1);\r\n            } else if (val > 1.7976931348623157e+308) { // +-Infinity\r\n                writeUint(0, buf, pos + off0);\r\n                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);\r\n            } else {\r\n                var mantissa;\r\n                if (val < 2.2250738585072014e-308) { // denormal\r\n                    mantissa = val / 5e-324;\r\n                    writeUint(mantissa >>> 0, buf, pos + off0);\r\n                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);\r\n                } else {\r\n                    var exponent = Math.floor(Math.log(val) / Math.LN2);\r\n                    if (exponent === 1024)\r\n                        exponent = 1023;\r\n                    mantissa = val * Math.pow(2, -exponent);\r\n                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);\r\n                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);\r\n                }\r\n            }\r\n        }\r\n\r\n        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);\r\n        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);\r\n\r\n        function readDouble_ieee754(readUint, off0, off1, buf, pos) {\r\n            var lo = readUint(buf, pos + off0),\r\n                hi = readUint(buf, pos + off1);\r\n            var sign = (hi >> 31) * 2 + 1,\r\n                exponent = hi >>> 20 & 2047,\r\n                mantissa = 4294967296 * (hi & 1048575) + lo;\r\n            return exponent === 2047\r\n                ? mantissa\r\n                ? NaN\r\n                : sign * Infinity\r\n                : exponent === 0 // denormal\r\n                ? sign * 5e-324 * mantissa\r\n                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);\r\n        }\r\n\r\n        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);\r\n        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);\r\n\r\n    })();\r\n\r\n    return exports;\r\n}\r\n\r\n// uint helpers\r\n\r\nfunction writeUintLE(val, buf, pos) {\r\n    buf[pos    ] =  val        & 255;\r\n    buf[pos + 1] =  val >>> 8  & 255;\r\n    buf[pos + 2] =  val >>> 16 & 255;\r\n    buf[pos + 3] =  val >>> 24;\r\n}\r\n\r\nfunction writeUintBE(val, buf, pos) {\r\n    buf[pos    ] =  val >>> 24;\r\n    buf[pos + 1] =  val >>> 16 & 255;\r\n    buf[pos + 2] =  val >>> 8  & 255;\r\n    buf[pos + 3] =  val        & 255;\r\n}\r\n\r\nfunction readUintLE(buf, pos) {\r\n    return (buf[pos    ]\r\n          | buf[pos + 1] << 8\r\n          | buf[pos + 2] << 16\r\n          | buf[pos + 3] << 24) >>> 0;\r\n}\r\n\r\nfunction readUintBE(buf, pos) {\r\n    return (buf[pos    ] << 24\r\n          | buf[pos + 1] << 16\r\n          | buf[pos + 2] << 8\r\n          | buf[pos + 3]) >>> 0;\r\n}\r\n","\"use strict\";\r\nmodule.exports = inquire;\r\n\r\n/**\r\n * Requires a module only if available.\r\n * @memberof util\r\n * @param {string} moduleName Module to require\r\n * @returns {?Object} Required module if available and not empty, otherwise `null`\r\n */\r\nfunction inquire(moduleName) {\r\n    try {\r\n        var mod = eval(\"quire\".replace(/^/,\"re\"))(moduleName); // eslint-disable-line no-eval\r\n        if (mod && (mod.length || Object.keys(mod).length))\r\n            return mod;\r\n    } catch (e) {} // eslint-disable-line no-empty\r\n    return null;\r\n}\r\n","\"use strict\";\r\nmodule.exports = pool;\r\n\r\n/**\r\n * An allocator as used by {@link util.pool}.\r\n * @typedef PoolAllocator\r\n * @type {function}\r\n * @param {number} size Buffer size\r\n * @returns {Uint8Array} Buffer\r\n */\r\n\r\n/**\r\n * A slicer as used by {@link util.pool}.\r\n * @typedef PoolSlicer\r\n * @type {function}\r\n * @param {number} start Start offset\r\n * @param {number} end End offset\r\n * @returns {Uint8Array} Buffer slice\r\n * @this {Uint8Array}\r\n */\r\n\r\n/**\r\n * A general purpose buffer pool.\r\n * @memberof util\r\n * @function\r\n * @param {PoolAllocator} alloc Allocator\r\n * @param {PoolSlicer} slice Slicer\r\n * @param {number} [size=8192] Slab size\r\n * @returns {PoolAllocator} Pooled allocator\r\n */\r\nfunction pool(alloc, slice, size) {\r\n    var SIZE   = size || 8192;\r\n    var MAX    = SIZE >>> 1;\r\n    var slab   = null;\r\n    var offset = SIZE;\r\n    return function pool_alloc(size) {\r\n        if (size < 1 || size > MAX)\r\n            return alloc(size);\r\n        if (offset + size > SIZE) {\r\n            slab = alloc(SIZE);\r\n            offset = 0;\r\n        }\r\n        var buf = slice.call(slab, offset, offset += size);\r\n        if (offset & 7) // align to 32 bit\r\n            offset = (offset | 7) + 1;\r\n        return buf;\r\n    };\r\n}\r\n","\"use strict\";\r\n\r\n/**\r\n * A minimal UTF8 implementation for number arrays.\r\n * @memberof util\r\n * @namespace\r\n */\r\nvar utf8 = exports;\r\n\r\n/**\r\n * Calculates the UTF8 byte length of a string.\r\n * @param {string} string String\r\n * @returns {number} Byte length\r\n */\r\nutf8.length = function utf8_length(string) {\r\n    var len = 0,\r\n        c = 0;\r\n    for (var i = 0; i < string.length; ++i) {\r\n        c = string.charCodeAt(i);\r\n        if (c < 128)\r\n            len += 1;\r\n        else if (c < 2048)\r\n            len += 2;\r\n        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {\r\n            ++i;\r\n            len += 4;\r\n        } else\r\n            len += 3;\r\n    }\r\n    return len;\r\n};\r\n\r\n/**\r\n * Reads UTF8 bytes as a string.\r\n * @param {Uint8Array} buffer Source buffer\r\n * @param {number} start Source start\r\n * @param {number} end Source end\r\n * @returns {string} String read\r\n */\r\nutf8.read = function utf8_read(buffer, start, end) {\r\n    var len = end - start;\r\n    if (len < 1)\r\n        return \"\";\r\n    var parts = null,\r\n        chunk = [],\r\n        i = 0, // char offset\r\n        t;     // temporary\r\n    while (start < end) {\r\n        t = buffer[start++];\r\n        if (t < 128)\r\n            chunk[i++] = t;\r\n        else if (t > 191 && t < 224)\r\n            chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;\r\n        else if (t > 239 && t < 365) {\r\n            t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;\r\n            chunk[i++] = 0xD800 + (t >> 10);\r\n            chunk[i++] = 0xDC00 + (t & 1023);\r\n        } else\r\n            chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;\r\n        if (i > 8191) {\r\n            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));\r\n            i = 0;\r\n        }\r\n    }\r\n    if (parts) {\r\n        if (i)\r\n            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));\r\n        return parts.join(\"\");\r\n    }\r\n    return String.fromCharCode.apply(String, chunk.slice(0, i));\r\n};\r\n\r\n/**\r\n * Writes a string as UTF8 bytes.\r\n * @param {string} string Source string\r\n * @param {Uint8Array} buffer Destination buffer\r\n * @param {number} offset Destination offset\r\n * @returns {number} Bytes written\r\n */\r\nutf8.write = function utf8_write(string, buffer, offset) {\r\n    var start = offset,\r\n        c1, // character 1\r\n        c2; // character 2\r\n    for (var i = 0; i < string.length; ++i) {\r\n        c1 = string.charCodeAt(i);\r\n        if (c1 < 128) {\r\n            buffer[offset++] = c1;\r\n        } else if (c1 < 2048) {\r\n            buffer[offset++] = c1 >> 6       | 192;\r\n            buffer[offset++] = c1       & 63 | 128;\r\n        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {\r\n            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);\r\n            ++i;\r\n            buffer[offset++] = c1 >> 18      | 240;\r\n            buffer[offset++] = c1 >> 12 & 63 | 128;\r\n            buffer[offset++] = c1 >> 6  & 63 | 128;\r\n            buffer[offset++] = c1       & 63 | 128;\r\n        } else {\r\n            buffer[offset++] = c1 >> 12      | 224;\r\n            buffer[offset++] = c1 >> 6  & 63 | 128;\r\n            buffer[offset++] = c1       & 63 | 128;\r\n        }\r\n    }\r\n    return offset - start;\r\n};\r\n","'use strict';\n\nvar objectAssign = require('object-assign');\n\n// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\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 */\nfunction compare(a, b) {\n  if (a === b) {\n    return 0;\n  }\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) {\n    return -1;\n  }\n  if (y < x) {\n    return 1;\n  }\n  return 0;\n}\nfunction isBuffer(b) {\n  if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {\n    return global.Buffer.isBuffer(b);\n  }\n  return !!(b != null && b._isBuffer);\n}\n\n// based on node assert, original notice:\n// NB: The URL to the CommonJS spec is kept just for tradition.\n//     node-assert has evolved a lot since then, both in API and behavior.\n\n// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar util = require('util/');\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar pSlice = Array.prototype.slice;\nvar functionsHaveNames = (function () {\n  return function foo() {}.name === 'foo';\n}());\nfunction pToString (obj) {\n  return Object.prototype.toString.call(obj);\n}\nfunction isView(arrbuf) {\n  if (isBuffer(arrbuf)) {\n    return false;\n  }\n  if (typeof global.ArrayBuffer !== 'function') {\n    return false;\n  }\n  if (typeof ArrayBuffer.isView === 'function') {\n    return ArrayBuffer.isView(arrbuf);\n  }\n  if (!arrbuf) {\n    return false;\n  }\n  if (arrbuf instanceof DataView) {\n    return true;\n  }\n  if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {\n    return true;\n  }\n  return false;\n}\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n//                             actual: actual,\n//                             expected: expected })\n\nvar regex = /\\s*function\\s+([^\\(\\s]*)\\s*/;\n// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js\nfunction getName(func) {\n  if (!util.isFunction(func)) {\n    return;\n  }\n  if (functionsHaveNames) {\n    return func.name;\n  }\n  var str = func.toString();\n  var match = str.match(regex);\n  return match && match[1];\n}\nassert.AssertionError = function AssertionError(options) {\n  this.name = 'AssertionError';\n  this.actual = options.actual;\n  this.expected = options.expected;\n  this.operator = options.operator;\n  if (options.message) {\n    this.message = options.message;\n    this.generatedMessage = false;\n  } else {\n    this.message = getMessage(this);\n    this.generatedMessage = true;\n  }\n  var stackStartFunction = options.stackStartFunction || fail;\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, stackStartFunction);\n  } else {\n    // non v8 browsers so we can have a stacktrace\n    var err = new Error();\n    if (err.stack) {\n      var out = err.stack;\n\n      // try to strip useless frames\n      var fn_name = getName(stackStartFunction);\n      var idx = out.indexOf('\\n' + fn_name);\n      if (idx >= 0) {\n        // once we have located the function frame\n        // we need to strip out everything before it (and its line)\n        var next_line = out.indexOf('\\n', idx + 1);\n        out = out.substring(next_line + 1);\n      }\n\n      this.stack = out;\n    }\n  }\n};\n\n// assert.AssertionError instanceof Error\nutil.inherits(assert.AssertionError, Error);\n\nfunction truncate(s, n) {\n  if (typeof s === 'string') {\n    return s.length < n ? s : s.slice(0, n);\n  } else {\n    return s;\n  }\n}\nfunction inspect(something) {\n  if (functionsHaveNames || !util.isFunction(something)) {\n    return util.inspect(something);\n  }\n  var rawname = getName(something);\n  var name = rawname ? ': ' + rawname : '';\n  return '[Function' +  name + ']';\n}\nfunction getMessage(self) {\n  return truncate(inspect(self.actual), 128) + ' ' +\n         self.operator + ' ' +\n         truncate(inspect(self.expected), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided.  All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n  throw new assert.AssertionError({\n    message: message,\n    actual: actual,\n    expected: expected,\n    operator: operator,\n    stackStartFunction: stackStartFunction\n  });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nfunction ok(value, message) {\n  if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n  if (actual != expected) fail(actual, expected, message, '==', assert.equal);\n};\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n  if (actual == expected) {\n    fail(actual, expected, message, '!=', assert.notEqual);\n  }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n  }\n};\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);\n  }\n};\n\nfunction _deepEqual(actual, expected, strict, memos) {\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n  } else if (isBuffer(actual) && isBuffer(expected)) {\n    return compare(actual, expected) === 0;\n\n  // 7.2. If the expected value is a Date object, the actual value is\n  // equivalent if it is also a Date object that refers to the same time.\n  } else if (util.isDate(actual) && util.isDate(expected)) {\n    return actual.getTime() === expected.getTime();\n\n  // 7.3 If the expected value is a RegExp object, the actual value is\n  // equivalent if it is also a RegExp object with the same source and\n  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {\n    return actual.source === expected.source &&\n           actual.global === expected.global &&\n           actual.multiline === expected.multiline &&\n           actual.lastIndex === expected.lastIndex &&\n           actual.ignoreCase === expected.ignoreCase;\n\n  // 7.4. Other pairs that do not both pass typeof value == 'object',\n  // equivalence is determined by ==.\n  } else if ((actual === null || typeof actual !== 'object') &&\n             (expected === null || typeof expected !== 'object')) {\n    return strict ? actual === expected : actual == expected;\n\n  // If both values are instances of typed arrays, wrap their underlying\n  // ArrayBuffers in a Buffer each to increase performance\n  // This optimization requires the arrays to have the same type as checked by\n  // Object.prototype.toString (aka pToString). Never perform binary\n  // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their\n  // bit patterns are not identical.\n  } else if (isView(actual) && isView(expected) &&\n             pToString(actual) === pToString(expected) &&\n             !(actual instanceof Float32Array ||\n               actual instanceof Float64Array)) {\n    return compare(new Uint8Array(actual.buffer),\n                   new Uint8Array(expected.buffer)) === 0;\n\n  // 7.5 For all other Object pairs, including Array objects, equivalence is\n  // determined by having the same number of owned properties (as verified\n  // with Object.prototype.hasOwnProperty.call), the same set of keys\n  // (although not necessarily the same order), equivalent values for every\n  // corresponding key, and an identical 'prototype' property. Note: this\n  // accounts for both named and indexed properties on Arrays.\n  } else if (isBuffer(actual) !== isBuffer(expected)) {\n    return false;\n  } else {\n    memos = memos || {actual: [], expected: []};\n\n    var actualIndex = memos.actual.indexOf(actual);\n    if (actualIndex !== -1) {\n      if (actualIndex === memos.expected.indexOf(expected)) {\n        return true;\n      }\n    }\n\n    memos.actual.push(actual);\n    memos.expected.push(expected);\n\n    return objEquiv(actual, expected, strict, memos);\n  }\n}\n\nfunction isArguments(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b, strict, actualVisitedObjects) {\n  if (a === null || a === undefined || b === null || b === undefined)\n    return false;\n  // if one is a primitive, the other must be same\n  if (util.isPrimitive(a) || util.isPrimitive(b))\n    return a === b;\n  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))\n    return false;\n  var aIsArgs = isArguments(a);\n  var bIsArgs = isArguments(b);\n  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))\n    return false;\n  if (aIsArgs) {\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return _deepEqual(a, b, strict);\n  }\n  var ka = objectKeys(a);\n  var kb = objectKeys(b);\n  var key, i;\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length !== kb.length)\n    return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] !== kb[i])\n      return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))\n      return false;\n  }\n  return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n  }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nfunction notDeepStrictEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);\n  }\n}\n\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n  if (actual !== expected) {\n    fail(actual, expected, message, '===', assert.strictEqual);\n  }\n};\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n  if (actual === expected) {\n    fail(actual, expected, message, '!==', assert.notStrictEqual);\n  }\n};\n\nfunction expectedException(actual, expected) {\n  if (!actual || !expected) {\n    return false;\n  }\n\n  if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n    return expected.test(actual);\n  }\n\n  try {\n    if (actual instanceof expected) {\n      return true;\n    }\n  } catch (e) {\n    // Ignore.  The instanceof check doesn't work for arrow functions.\n  }\n\n  if (Error.isPrototypeOf(expected)) {\n    return false;\n  }\n\n  return expected.call({}, actual) === true;\n}\n\nfunction _tryBlock(block) {\n  var error;\n  try {\n    block();\n  } catch (e) {\n    error = e;\n  }\n  return error;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n  var actual;\n\n  if (typeof block !== 'function') {\n    throw new TypeError('\"block\" argument must be a function');\n  }\n\n  if (typeof expected === 'string') {\n    message = expected;\n    expected = null;\n  }\n\n  actual = _tryBlock(block);\n\n  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +\n            (message ? ' ' + message : '.');\n\n  if (shouldThrow && !actual) {\n    fail(actual, expected, 'Missing expected exception' + message);\n  }\n\n  var userProvidedMessage = typeof message === 'string';\n  var isUnwantedException = !shouldThrow && util.isError(actual);\n  var isUnexpectedException = !shouldThrow && actual && !expected;\n\n  if ((isUnwantedException &&\n      userProvidedMessage &&\n      expectedException(actual, expected)) ||\n      isUnexpectedException) {\n    fail(actual, expected, 'Got unwanted exception' + message);\n  }\n\n  if ((shouldThrow && actual && expected &&\n      !expectedException(actual, expected)) || (!shouldThrow && actual)) {\n    throw actual;\n  }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\n\nassert.throws = function(block, /*optional*/error, /*optional*/message) {\n  _throws(true, block, error, message);\n};\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {\n  _throws(false, block, error, message);\n};\n\nassert.ifError = function(err) { if (err) throw err; };\n\n// Expose a strict only variant of assert\nfunction strict(value, message) {\n  if (!value) fail(value, true, message, '==', strict);\n}\nassert.strict = objectAssign(strict, assert, {\n  equal: assert.strictEqual,\n  deepEqual: assert.deepStrictEqual,\n  notEqual: assert.notStrictEqual,\n  notDeepEqual: assert.notDeepStrictEqual\n});\nassert.strict.strict = assert.strict;\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    if (hasOwn.call(obj, key)) keys.push(key);\n  }\n  return keys;\n};\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    var TempCtor = function () {}\n    TempCtor.prototype = superCtor.prototype\n    ctor.prototype = new TempCtor()\n    ctor.prototype.constructor = ctor\n  }\n}\n","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  // Allow for deprecating things in the process of starting up.\n  if (isUndefined(global.process)) {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  if (process.noDeprecation === true) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n  if (isUndefined(debugEnviron))\n    debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\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  var i\n  for (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(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\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","var bigInt = (function (undefined) {\r\n    \"use strict\";\r\n\r\n    var BASE = 1e7,\r\n        LOG_BASE = 7,\r\n        MAX_INT = 9007199254740992,\r\n        MAX_INT_ARR = smallToArray(MAX_INT),\r\n        DEFAULT_ALPHABET = \"0123456789abcdefghijklmnopqrstuvwxyz\";\r\n\r\n    var supportsNativeBigInt = typeof BigInt === \"function\";\r\n\r\n    function Integer(v, radix, alphabet, caseSensitive) {\r\n        if (typeof v === \"undefined\") return Integer[0];\r\n        if (typeof radix !== \"undefined\") return +radix === 10 && !alphabet ? parseValue(v) : parseBase(v, radix, alphabet, caseSensitive);\r\n        return parseValue(v);\r\n    }\r\n\r\n    function BigInteger(value, sign) {\r\n        this.value = value;\r\n        this.sign = sign;\r\n        this.isSmall = false;\r\n    }\r\n    BigInteger.prototype = Object.create(Integer.prototype);\r\n\r\n    function SmallInteger(value) {\r\n        this.value = value;\r\n        this.sign = value < 0;\r\n        this.isSmall = true;\r\n    }\r\n    SmallInteger.prototype = Object.create(Integer.prototype);\r\n\r\n    function NativeBigInt(value) {\r\n        this.value = value;\r\n    }\r\n    NativeBigInt.prototype = Object.create(Integer.prototype);\r\n\r\n    function isPrecise(n) {\r\n        return -MAX_INT < n && n < MAX_INT;\r\n    }\r\n\r\n    function smallToArray(n) { // For performance reasons doesn't reference BASE, need to change this function if BASE changes\r\n        if (n < 1e7)\r\n            return [n];\r\n        if (n < 1e14)\r\n            return [n % 1e7, Math.floor(n / 1e7)];\r\n        return [n % 1e7, Math.floor(n / 1e7) % 1e7, Math.floor(n / 1e14)];\r\n    }\r\n\r\n    function arrayToSmall(arr) { // If BASE changes this function may need to change\r\n        trim(arr);\r\n        var length = arr.length;\r\n        if (length < 4 && compareAbs(arr, MAX_INT_ARR) < 0) {\r\n            switch (length) {\r\n                case 0: return 0;\r\n                case 1: return arr[0];\r\n                case 2: return arr[0] + arr[1] * BASE;\r\n                default: return arr[0] + (arr[1] + arr[2] * BASE) * BASE;\r\n            }\r\n        }\r\n        return arr;\r\n    }\r\n\r\n    function trim(v) {\r\n        var i = v.length;\r\n        while (v[--i] === 0);\r\n        v.length = i + 1;\r\n    }\r\n\r\n    function createArray(length) { // function shamelessly stolen from Yaffle's library https://github.com/Yaffle/BigInteger\r\n        var x = new Array(length);\r\n        var i = -1;\r\n        while (++i < length) {\r\n            x[i] = 0;\r\n        }\r\n        return x;\r\n    }\r\n\r\n    function truncate(n) {\r\n        if (n > 0) return Math.floor(n);\r\n        return Math.ceil(n);\r\n    }\r\n\r\n    function add(a, b) { // assumes a and b are arrays with a.length >= b.length\r\n        var l_a = a.length,\r\n            l_b = b.length,\r\n            r = new Array(l_a),\r\n            carry = 0,\r\n            base = BASE,\r\n            sum, i;\r\n        for (i = 0; i < l_b; i++) {\r\n            sum = a[i] + b[i] + carry;\r\n            carry = sum >= base ? 1 : 0;\r\n            r[i] = sum - carry * base;\r\n        }\r\n        while (i < l_a) {\r\n            sum = a[i] + carry;\r\n            carry = sum === base ? 1 : 0;\r\n            r[i++] = sum - carry * base;\r\n        }\r\n        if (carry > 0) r.push(carry);\r\n        return r;\r\n    }\r\n\r\n    function addAny(a, b) {\r\n        if (a.length >= b.length) return add(a, b);\r\n        return add(b, a);\r\n    }\r\n\r\n    function addSmall(a, carry) { // assumes a is array, carry is number with 0 <= carry < MAX_INT\r\n        var l = a.length,\r\n            r = new Array(l),\r\n            base = BASE,\r\n            sum, i;\r\n        for (i = 0; i < l; i++) {\r\n            sum = a[i] - base + carry;\r\n            carry = Math.floor(sum / base);\r\n            r[i] = sum - carry * base;\r\n            carry += 1;\r\n        }\r\n        while (carry > 0) {\r\n            r[i++] = carry % base;\r\n            carry = Math.floor(carry / base);\r\n        }\r\n        return r;\r\n    }\r\n\r\n    BigInteger.prototype.add = function (v) {\r\n        var n = parseValue(v);\r\n        if (this.sign !== n.sign) {\r\n            return this.subtract(n.negate());\r\n        }\r\n        var a = this.value, b = n.value;\r\n        if (n.isSmall) {\r\n            return new BigInteger(addSmall(a, Math.abs(b)), this.sign);\r\n        }\r\n        return new BigInteger(addAny(a, b), this.sign);\r\n    };\r\n    BigInteger.prototype.plus = BigInteger.prototype.add;\r\n\r\n    SmallInteger.prototype.add = function (v) {\r\n        var n = parseValue(v);\r\n        var a = this.value;\r\n        if (a < 0 !== n.sign) {\r\n            return this.subtract(n.negate());\r\n        }\r\n        var b = n.value;\r\n        if (n.isSmall) {\r\n            if (isPrecise(a + b)) return new SmallInteger(a + b);\r\n            b = smallToArray(Math.abs(b));\r\n        }\r\n        return new BigInteger(addSmall(b, Math.abs(a)), a < 0);\r\n    };\r\n    SmallInteger.prototype.plus = SmallInteger.prototype.add;\r\n\r\n    NativeBigInt.prototype.add = function (v) {\r\n        return new NativeBigInt(this.value + parseValue(v).value);\r\n    }\r\n    NativeBigInt.prototype.plus = NativeBigInt.prototype.add;\r\n\r\n    function subtract(a, b) { // assumes a and b are arrays with a >= b\r\n        var a_l = a.length,\r\n            b_l = b.length,\r\n            r = new Array(a_l),\r\n            borrow = 0,\r\n            base = BASE,\r\n            i, difference;\r\n        for (i = 0; i < b_l; i++) {\r\n            difference = a[i] - borrow - b[i];\r\n            if (difference < 0) {\r\n                difference += base;\r\n                borrow = 1;\r\n            } else borrow = 0;\r\n            r[i] = difference;\r\n        }\r\n        for (i = b_l; i < a_l; i++) {\r\n            difference = a[i] - borrow;\r\n            if (difference < 0) difference += base;\r\n            else {\r\n                r[i++] = difference;\r\n                break;\r\n            }\r\n            r[i] = difference;\r\n        }\r\n        for (; i < a_l; i++) {\r\n            r[i] = a[i];\r\n        }\r\n        trim(r);\r\n        return r;\r\n    }\r\n\r\n    function subtractAny(a, b, sign) {\r\n        var value;\r\n        if (compareAbs(a, b) >= 0) {\r\n            value = subtract(a, b);\r\n        } else {\r\n            value = subtract(b, a);\r\n            sign = !sign;\r\n        }\r\n        value = arrayToSmall(value);\r\n        if (typeof value === \"number\") {\r\n            if (sign) value = -value;\r\n            return new SmallInteger(value);\r\n        }\r\n        return new BigInteger(value, sign);\r\n    }\r\n\r\n    function subtractSmall(a, b, sign) { // assumes a is array, b is number with 0 <= b < MAX_INT\r\n        var l = a.length,\r\n            r = new Array(l),\r\n            carry = -b,\r\n            base = BASE,\r\n            i, difference;\r\n        for (i = 0; i < l; i++) {\r\n            difference = a[i] + carry;\r\n            carry = Math.floor(difference / base);\r\n            difference %= base;\r\n            r[i] = difference < 0 ? difference + base : difference;\r\n        }\r\n        r = arrayToSmall(r);\r\n        if (typeof r === \"number\") {\r\n            if (sign) r = -r;\r\n            return new SmallInteger(r);\r\n        } return new BigInteger(r, sign);\r\n    }\r\n\r\n    BigInteger.prototype.subtract = function (v) {\r\n        var n = parseValue(v);\r\n        if (this.sign !== n.sign) {\r\n            return this.add(n.negate());\r\n        }\r\n        var a = this.value, b = n.value;\r\n        if (n.isSmall)\r\n            return subtractSmall(a, Math.abs(b), this.sign);\r\n        return subtractAny(a, b, this.sign);\r\n    };\r\n    BigInteger.prototype.minus = BigInteger.prototype.subtract;\r\n\r\n    SmallInteger.prototype.subtract = function (v) {\r\n        var n = parseValue(v);\r\n        var a = this.value;\r\n        if (a < 0 !== n.sign) {\r\n            return this.add(n.negate());\r\n        }\r\n        var b = n.value;\r\n        if (n.isSmall) {\r\n            return new SmallInteger(a - b);\r\n        }\r\n        return subtractSmall(b, Math.abs(a), a >= 0);\r\n    };\r\n    SmallInteger.prototype.minus = SmallInteger.prototype.subtract;\r\n\r\n    NativeBigInt.prototype.subtract = function (v) {\r\n        return new NativeBigInt(this.value - parseValue(v).value);\r\n    }\r\n    NativeBigInt.prototype.minus = NativeBigInt.prototype.subtract;\r\n\r\n    BigInteger.prototype.negate = function () {\r\n        return new BigInteger(this.value, !this.sign);\r\n    };\r\n    SmallInteger.prototype.negate = function () {\r\n        var sign = this.sign;\r\n        var small = new SmallInteger(-this.value);\r\n        small.sign = !sign;\r\n        return small;\r\n    };\r\n    NativeBigInt.prototype.negate = function () {\r\n        return new NativeBigInt(-this.value);\r\n    }\r\n\r\n    BigInteger.prototype.abs = function () {\r\n        return new BigInteger(this.value, false);\r\n    };\r\n    SmallInteger.prototype.abs = function () {\r\n        return new SmallInteger(Math.abs(this.value));\r\n    };\r\n    NativeBigInt.prototype.abs = function () {\r\n        return new NativeBigInt(this.value >= 0 ? this.value : -this.value);\r\n    }\r\n\r\n\r\n    function multiplyLong(a, b) {\r\n        var a_l = a.length,\r\n            b_l = b.length,\r\n            l = a_l + b_l,\r\n            r = createArray(l),\r\n            base = BASE,\r\n            product, carry, i, a_i, b_j;\r\n        for (i = 0; i < a_l; ++i) {\r\n            a_i = a[i];\r\n            for (var j = 0; j < b_l; ++j) {\r\n                b_j = b[j];\r\n                product = a_i * b_j + r[i + j];\r\n                carry = Math.floor(product / base);\r\n                r[i + j] = product - carry * base;\r\n                r[i + j + 1] += carry;\r\n            }\r\n        }\r\n        trim(r);\r\n        return r;\r\n    }\r\n\r\n    function multiplySmall(a, b) { // assumes a is array, b is number with |b| < BASE\r\n        var l = a.length,\r\n            r = new Array(l),\r\n            base = BASE,\r\n            carry = 0,\r\n            product, i;\r\n        for (i = 0; i < l; i++) {\r\n            product = a[i] * b + carry;\r\n            carry = Math.floor(product / base);\r\n            r[i] = product - carry * base;\r\n        }\r\n        while (carry > 0) {\r\n            r[i++] = carry % base;\r\n            carry = Math.floor(carry / base);\r\n        }\r\n        return r;\r\n    }\r\n\r\n    function shiftLeft(x, n) {\r\n        var r = [];\r\n        while (n-- > 0) r.push(0);\r\n        return r.concat(x);\r\n    }\r\n\r\n    function multiplyKaratsuba(x, y) {\r\n        var n = Math.max(x.length, y.length);\r\n\r\n        if (n <= 30) return multiplyLong(x, y);\r\n        n = Math.ceil(n / 2);\r\n\r\n        var b = x.slice(n),\r\n            a = x.slice(0, n),\r\n            d = y.slice(n),\r\n            c = y.slice(0, n);\r\n\r\n        var ac = multiplyKaratsuba(a, c),\r\n            bd = multiplyKaratsuba(b, d),\r\n            abcd = multiplyKaratsuba(addAny(a, b), addAny(c, d));\r\n\r\n        var product = addAny(addAny(ac, shiftLeft(subtract(subtract(abcd, ac), bd), n)), shiftLeft(bd, 2 * n));\r\n        trim(product);\r\n        return product;\r\n    }\r\n\r\n    // The following function is derived from a surface fit of a graph plotting the performance difference\r\n    // between long multiplication and karatsuba multiplication versus the lengths of the two arrays.\r\n    function useKaratsuba(l1, l2) {\r\n        return -0.012 * l1 - 0.012 * l2 + 0.000015 * l1 * l2 > 0;\r\n    }\r\n\r\n    BigInteger.prototype.multiply = function (v) {\r\n        var n = parseValue(v),\r\n            a = this.value, b = n.value,\r\n            sign = this.sign !== n.sign,\r\n            abs;\r\n        if (n.isSmall) {\r\n            if (b === 0) return Integer[0];\r\n            if (b === 1) return this;\r\n            if (b === -1) return this.negate();\r\n            abs = Math.abs(b);\r\n            if (abs < BASE) {\r\n                return new BigInteger(multiplySmall(a, abs), sign);\r\n            }\r\n            b = smallToArray(abs);\r\n        }\r\n        if (useKaratsuba(a.length, b.length)) // Karatsuba is only faster for certain array sizes\r\n            return new BigInteger(multiplyKaratsuba(a, b), sign);\r\n        return new BigInteger(multiplyLong(a, b), sign);\r\n    };\r\n\r\n    BigInteger.prototype.times = BigInteger.prototype.multiply;\r\n\r\n    function multiplySmallAndArray(a, b, sign) { // a >= 0\r\n        if (a < BASE) {\r\n            return new BigInteger(multiplySmall(b, a), sign);\r\n        }\r\n        return new BigInteger(multiplyLong(b, smallToArray(a)), sign);\r\n    }\r\n    SmallInteger.prototype._multiplyBySmall = function (a) {\r\n        if (isPrecise(a.value * this.value)) {\r\n            return new SmallInteger(a.value * this.value);\r\n        }\r\n        return multiplySmallAndArray(Math.abs(a.value), smallToArray(Math.abs(this.value)), this.sign !== a.sign);\r\n    };\r\n    BigInteger.prototype._multiplyBySmall = function (a) {\r\n        if (a.value === 0) return Integer[0];\r\n        if (a.value === 1) return this;\r\n        if (a.value === -1) return this.negate();\r\n        return multiplySmallAndArray(Math.abs(a.value), this.value, this.sign !== a.sign);\r\n    };\r\n    SmallInteger.prototype.multiply = function (v) {\r\n        return parseValue(v)._multiplyBySmall(this);\r\n    };\r\n    SmallInteger.prototype.times = SmallInteger.prototype.multiply;\r\n\r\n    NativeBigInt.prototype.multiply = function (v) {\r\n        return new NativeBigInt(this.value * parseValue(v).value);\r\n    }\r\n    NativeBigInt.prototype.times = NativeBigInt.prototype.multiply;\r\n\r\n    function square(a) {\r\n        //console.assert(2 * BASE * BASE < MAX_INT);\r\n        var l = a.length,\r\n            r = createArray(l + l),\r\n            base = BASE,\r\n            product, carry, i, a_i, a_j;\r\n        for (i = 0; i < l; i++) {\r\n            a_i = a[i];\r\n            carry = 0 - a_i * a_i;\r\n            for (var j = i; j < l; j++) {\r\n                a_j = a[j];\r\n                product = 2 * (a_i * a_j) + r[i + j] + carry;\r\n                carry = Math.floor(product / base);\r\n                r[i + j] = product - carry * base;\r\n            }\r\n            r[i + l] = carry;\r\n        }\r\n        trim(r);\r\n        return r;\r\n    }\r\n\r\n    BigInteger.prototype.square = function () {\r\n        return new BigInteger(square(this.value), false);\r\n    };\r\n\r\n    SmallInteger.prototype.square = function () {\r\n        var value = this.value * this.value;\r\n        if (isPrecise(value)) return new SmallInteger(value);\r\n        return new BigInteger(square(smallToArray(Math.abs(this.value))), false);\r\n    };\r\n\r\n    NativeBigInt.prototype.square = function (v) {\r\n        return new NativeBigInt(this.value * this.value);\r\n    }\r\n\r\n    function divMod1(a, b) { // Left over from previous version. Performs faster than divMod2 on smaller input sizes.\r\n        var a_l = a.length,\r\n            b_l = b.length,\r\n            base = BASE,\r\n            result = createArray(b.length),\r\n            divisorMostSignificantDigit = b[b_l - 1],\r\n            // normalization\r\n            lambda = Math.ceil(base / (2 * divisorMostSignificantDigit)),\r\n            remainder = multiplySmall(a, lambda),\r\n            divisor = multiplySmall(b, lambda),\r\n            quotientDigit, shift, carry, borrow, i, l, q;\r\n        if (remainder.length <= a_l) remainder.push(0);\r\n        divisor.push(0);\r\n        divisorMostSignificantDigit = divisor[b_l - 1];\r\n        for (shift = a_l - b_l; shift >= 0; shift--) {\r\n            quotientDigit = base - 1;\r\n            if (remainder[shift + b_l] !== divisorMostSignificantDigit) {\r\n                quotientDigit = Math.floor((remainder[shift + b_l] * base + remainder[shift + b_l - 1]) / divisorMostSignificantDigit);\r\n            }\r\n            // quotientDigit <= base - 1\r\n            carry = 0;\r\n            borrow = 0;\r\n            l = divisor.length;\r\n            for (i = 0; i < l; i++) {\r\n                carry += quotientDigit * divisor[i];\r\n                q = Math.floor(carry / base);\r\n                borrow += remainder[shift + i] - (carry - q * base);\r\n                carry = q;\r\n                if (borrow < 0) {\r\n                    remainder[shift + i] = borrow + base;\r\n                    borrow = -1;\r\n                } else {\r\n                    remainder[shift + i] = borrow;\r\n                    borrow = 0;\r\n                }\r\n            }\r\n            while (borrow !== 0) {\r\n                quotientDigit -= 1;\r\n                carry = 0;\r\n                for (i = 0; i < l; i++) {\r\n                    carry += remainder[shift + i] - base + divisor[i];\r\n                    if (carry < 0) {\r\n                        remainder[shift + i] = carry + base;\r\n                        carry = 0;\r\n                    } else {\r\n                        remainder[shift + i] = carry;\r\n                        carry = 1;\r\n                    }\r\n                }\r\n                borrow += carry;\r\n            }\r\n            result[shift] = quotientDigit;\r\n        }\r\n        // denormalization\r\n        remainder = divModSmall(remainder, lambda)[0];\r\n        return [arrayToSmall(result), arrayToSmall(remainder)];\r\n    }\r\n\r\n    function divMod2(a, b) { // Implementation idea shamelessly stolen from Silent Matt's library http://silentmatt.com/biginteger/\r\n        // Performs faster than divMod1 on larger input sizes.\r\n        var a_l = a.length,\r\n            b_l = b.length,\r\n            result = [],\r\n            part = [],\r\n            base = BASE,\r\n            guess, xlen, highx, highy, check;\r\n        while (a_l) {\r\n            part.unshift(a[--a_l]);\r\n            trim(part);\r\n            if (compareAbs(part, b) < 0) {\r\n                result.push(0);\r\n                continue;\r\n            }\r\n            xlen = part.length;\r\n            highx = part[xlen - 1] * base + part[xlen - 2];\r\n            highy = b[b_l - 1] * base + b[b_l - 2];\r\n            if (xlen > b_l) {\r\n                highx = (highx + 1) * base;\r\n            }\r\n            guess = Math.ceil(highx / highy);\r\n            do {\r\n                check = multiplySmall(b, guess);\r\n                if (compareAbs(check, part) <= 0) break;\r\n                guess--;\r\n            } while (guess);\r\n            result.push(guess);\r\n            part = subtract(part, check);\r\n        }\r\n        result.reverse();\r\n        return [arrayToSmall(result), arrayToSmall(part)];\r\n    }\r\n\r\n    function divModSmall(value, lambda) {\r\n        var length = value.length,\r\n            quotient = createArray(length),\r\n            base = BASE,\r\n            i, q, remainder, divisor;\r\n        remainder = 0;\r\n        for (i = length - 1; i >= 0; --i) {\r\n            divisor = remainder * base + value[i];\r\n            q = truncate(divisor / lambda);\r\n            remainder = divisor - q * lambda;\r\n            quotient[i] = q | 0;\r\n        }\r\n        return [quotient, remainder | 0];\r\n    }\r\n\r\n    function divModAny(self, v) {\r\n        var value, n = parseValue(v);\r\n        if (supportsNativeBigInt) {\r\n            return [new NativeBigInt(self.value / n.value), new NativeBigInt(self.value % n.value)];\r\n        }\r\n        var a = self.value, b = n.value;\r\n        var quotient;\r\n        if (b === 0) throw new Error(\"Cannot divide by zero\");\r\n        if (self.isSmall) {\r\n            if (n.isSmall) {\r\n                return [new SmallInteger(truncate(a / b)), new SmallInteger(a % b)];\r\n            }\r\n            return [Integer[0], self];\r\n        }\r\n        if (n.isSmall) {\r\n            if (b === 1) return [self, Integer[0]];\r\n            if (b == -1) return [self.negate(), Integer[0]];\r\n            var abs = Math.abs(b);\r\n            if (abs < BASE) {\r\n                value = divModSmall(a, abs);\r\n                quotient = arrayToSmall(value[0]);\r\n                var remainder = value[1];\r\n                if (self.sign) remainder = -remainder;\r\n                if (typeof quotient === \"number\") {\r\n                    if (self.sign !== n.sign) quotient = -quotient;\r\n                    return [new SmallInteger(quotient), new SmallInteger(remainder)];\r\n                }\r\n                return [new BigInteger(quotient, self.sign !== n.sign), new SmallInteger(remainder)];\r\n            }\r\n            b = smallToArray(abs);\r\n        }\r\n        var comparison = compareAbs(a, b);\r\n        if (comparison === -1) return [Integer[0], self];\r\n        if (comparison === 0) return [Integer[self.sign === n.sign ? 1 : -1], Integer[0]];\r\n\r\n        // divMod1 is faster on smaller input sizes\r\n        if (a.length + b.length <= 200)\r\n            value = divMod1(a, b);\r\n        else value = divMod2(a, b);\r\n\r\n        quotient = value[0];\r\n        var qSign = self.sign !== n.sign,\r\n            mod = value[1],\r\n            mSign = self.sign;\r\n        if (typeof quotient === \"number\") {\r\n            if (qSign) quotient = -quotient;\r\n            quotient = new SmallInteger(quotient);\r\n        } else quotient = new BigInteger(quotient, qSign);\r\n        if (typeof mod === \"number\") {\r\n            if (mSign) mod = -mod;\r\n            mod = new SmallInteger(mod);\r\n        } else mod = new BigInteger(mod, mSign);\r\n        return [quotient, mod];\r\n    }\r\n\r\n    BigInteger.prototype.divmod = function (v) {\r\n        var result = divModAny(this, v);\r\n        return {\r\n            quotient: result[0],\r\n            remainder: result[1]\r\n        };\r\n    };\r\n    NativeBigInt.prototype.divmod = SmallInteger.prototype.divmod = BigInteger.prototype.divmod;\r\n\r\n\r\n    BigInteger.prototype.divide = function (v) {\r\n        return divModAny(this, v)[0];\r\n    };\r\n    NativeBigInt.prototype.over = NativeBigInt.prototype.divide = function (v) {\r\n        return new NativeBigInt(this.value / parseValue(v).value);\r\n    };\r\n    SmallInteger.prototype.over = SmallInteger.prototype.divide = BigInteger.prototype.over = BigInteger.prototype.divide;\r\n\r\n    BigInteger.prototype.mod = function (v) {\r\n        return divModAny(this, v)[1];\r\n    };\r\n    NativeBigInt.prototype.mod = NativeBigInt.prototype.remainder = function (v) {\r\n        return new NativeBigInt(this.value % parseValue(v).value);\r\n    };\r\n    SmallInteger.prototype.remainder = SmallInteger.prototype.mod = BigInteger.prototype.remainder = BigInteger.prototype.mod;\r\n\r\n    BigInteger.prototype.pow = function (v) {\r\n        var n = parseValue(v),\r\n            a = this.value,\r\n            b = n.value,\r\n            value, x, y;\r\n        if (b === 0) return Integer[1];\r\n        if (a === 0) return Integer[0];\r\n        if (a === 1) return Integer[1];\r\n        if (a === -1) return n.isEven() ? Integer[1] : Integer[-1];\r\n        if (n.sign) {\r\n            return Integer[0];\r\n        }\r\n        if (!n.isSmall) throw new Error(\"The exponent \" + n.toString() + \" is too large.\");\r\n        if (this.isSmall) {\r\n            if (isPrecise(value = Math.pow(a, b)))\r\n                return new SmallInteger(truncate(value));\r\n        }\r\n        x = this;\r\n        y = Integer[1];\r\n        while (true) {\r\n            if (b & 1 === 1) {\r\n                y = y.times(x);\r\n                --b;\r\n            }\r\n            if (b === 0) break;\r\n            b /= 2;\r\n            x = x.square();\r\n        }\r\n        return y;\r\n    };\r\n    SmallInteger.prototype.pow = BigInteger.prototype.pow;\r\n\r\n    NativeBigInt.prototype.pow = function (v) {\r\n        var n = parseValue(v);\r\n        var a = this.value, b = n.value;\r\n        var _0 = BigInt(0), _1 = BigInt(1), _2 = BigInt(2);\r\n        if (b === _0) return Integer[1];\r\n        if (a === _0) return Integer[0];\r\n        if (a === _1) return Integer[1];\r\n        if (a === BigInt(-1)) return n.isEven() ? Integer[1] : Integer[-1];\r\n        if (n.isNegative()) return new NativeBigInt(_0);\r\n        var x = this;\r\n        var y = Integer[1];\r\n        while (true) {\r\n            if ((b & _1) === _1) {\r\n                y = y.times(x);\r\n                --b;\r\n            }\r\n            if (b === _0) break;\r\n            b /= _2;\r\n            x = x.square();\r\n        }\r\n        return y;\r\n    }\r\n\r\n    BigInteger.prototype.modPow = function (exp, mod) {\r\n        exp = parseValue(exp);\r\n        mod = parseValue(mod);\r\n        if (mod.isZero()) throw new Error(\"Cannot take modPow with modulus 0\");\r\n        var r = Integer[1],\r\n            base = this.mod(mod);\r\n        if (exp.isNegative()) {\r\n            exp = exp.multiply(Integer[-1]);\r\n            base = base.modInv(mod);\r\n        }\r\n        while (exp.isPositive()) {\r\n            if (base.isZero()) return Integer[0];\r\n            if (exp.isOdd()) r = r.multiply(base).mod(mod);\r\n            exp = exp.divide(2);\r\n            base = base.square().mod(mod);\r\n        }\r\n        return r;\r\n    };\r\n    NativeBigInt.prototype.modPow = SmallInteger.prototype.modPow = BigInteger.prototype.modPow;\r\n\r\n    function compareAbs(a, b) {\r\n        if (a.length !== b.length) {\r\n            return a.length > b.length ? 1 : -1;\r\n        }\r\n        for (var i = a.length - 1; i >= 0; i--) {\r\n            if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;\r\n        }\r\n        return 0;\r\n    }\r\n\r\n    BigInteger.prototype.compareAbs = function (v) {\r\n        var n = parseValue(v),\r\n            a = this.value,\r\n            b = n.value;\r\n        if (n.isSmall) return 1;\r\n        return compareAbs(a, b);\r\n    };\r\n    SmallInteger.prototype.compareAbs = function (v) {\r\n        var n = parseValue(v),\r\n            a = Math.abs(this.value),\r\n            b = n.value;\r\n        if (n.isSmall) {\r\n            b = Math.abs(b);\r\n            return a === b ? 0 : a > b ? 1 : -1;\r\n        }\r\n        return -1;\r\n    };\r\n    NativeBigInt.prototype.compareAbs = function (v) {\r\n        var a = this.value;\r\n        var b = parseValue(v).value;\r\n        a = a >= 0 ? a : -a;\r\n        b = b >= 0 ? b : -b;\r\n        return a === b ? 0 : a > b ? 1 : -1;\r\n    }\r\n\r\n    BigInteger.prototype.compare = function (v) {\r\n        // See discussion about comparison with Infinity:\r\n        // https://github.com/peterolson/BigInteger.js/issues/61\r\n        if (v === Infinity) {\r\n            return -1;\r\n        }\r\n        if (v === -Infinity) {\r\n            return 1;\r\n        }\r\n\r\n        var n = parseValue(v),\r\n            a = this.value,\r\n            b = n.value;\r\n        if (this.sign !== n.sign) {\r\n            return n.sign ? 1 : -1;\r\n        }\r\n        if (n.isSmall) {\r\n            return this.sign ? -1 : 1;\r\n        }\r\n        return compareAbs(a, b) * (this.sign ? -1 : 1);\r\n    };\r\n    BigInteger.prototype.compareTo = BigInteger.prototype.compare;\r\n\r\n    SmallInteger.prototype.compare = function (v) {\r\n        if (v === Infinity) {\r\n            return -1;\r\n        }\r\n        if (v === -Infinity) {\r\n            return 1;\r\n        }\r\n\r\n        var n = parseValue(v),\r\n            a = this.value,\r\n            b = n.value;\r\n        if (n.isSmall) {\r\n            return a == b ? 0 : a > b ? 1 : -1;\r\n        }\r\n        if (a < 0 !== n.sign) {\r\n            return a < 0 ? -1 : 1;\r\n        }\r\n        return a < 0 ? 1 : -1;\r\n    };\r\n    SmallInteger.prototype.compareTo = SmallInteger.prototype.compare;\r\n\r\n    NativeBigInt.prototype.compare = function (v) {\r\n        if (v === Infinity) {\r\n            return -1;\r\n        }\r\n        if (v === -Infinity) {\r\n            return 1;\r\n        }\r\n        var a = this.value;\r\n        var b = parseValue(v).value;\r\n        return a === b ? 0 : a > b ? 1 : -1;\r\n    }\r\n    NativeBigInt.prototype.compareTo = NativeBigInt.prototype.compare;\r\n\r\n    BigInteger.prototype.equals = function (v) {\r\n        return this.compare(v) === 0;\r\n    };\r\n    NativeBigInt.prototype.eq = NativeBigInt.prototype.equals = SmallInteger.prototype.eq = SmallInteger.prototype.equals = BigInteger.prototype.eq = BigInteger.prototype.equals;\r\n\r\n    BigInteger.prototype.notEquals = function (v) {\r\n        return this.compare(v) !== 0;\r\n    };\r\n    NativeBigInt.prototype.neq = NativeBigInt.prototype.notEquals = SmallInteger.prototype.neq = SmallInteger.prototype.notEquals = BigInteger.prototype.neq = BigInteger.prototype.notEquals;\r\n\r\n    BigInteger.prototype.greater = function (v) {\r\n        return this.compare(v) > 0;\r\n    };\r\n    NativeBigInt.prototype.gt = NativeBigInt.prototype.greater = SmallInteger.prototype.gt = SmallInteger.prototype.greater = BigInteger.prototype.gt = BigInteger.prototype.greater;\r\n\r\n    BigInteger.prototype.lesser = function (v) {\r\n        return this.compare(v) < 0;\r\n    };\r\n    NativeBigInt.prototype.lt = NativeBigInt.prototype.lesser = SmallInteger.prototype.lt = SmallInteger.prototype.lesser = BigInteger.prototype.lt = BigInteger.prototype.lesser;\r\n\r\n    BigInteger.prototype.greaterOrEquals = function (v) {\r\n        return this.compare(v) >= 0;\r\n    };\r\n    NativeBigInt.prototype.geq = NativeBigInt.prototype.greaterOrEquals = SmallInteger.prototype.geq = SmallInteger.prototype.greaterOrEquals = BigInteger.prototype.geq = BigInteger.prototype.greaterOrEquals;\r\n\r\n    BigInteger.prototype.lesserOrEquals = function (v) {\r\n        return this.compare(v) <= 0;\r\n    };\r\n    NativeBigInt.prototype.leq = NativeBigInt.prototype.lesserOrEquals = SmallInteger.prototype.leq = SmallInteger.prototype.lesserOrEquals = BigInteger.prototype.leq = BigInteger.prototype.lesserOrEquals;\r\n\r\n    BigInteger.prototype.isEven = function () {\r\n        return (this.value[0] & 1) === 0;\r\n    };\r\n    SmallInteger.prototype.isEven = function () {\r\n        return (this.value & 1) === 0;\r\n    };\r\n    NativeBigInt.prototype.isEven = function () {\r\n        return (this.value & BigInt(1)) === BigInt(0);\r\n    }\r\n\r\n    BigInteger.prototype.isOdd = function () {\r\n        return (this.value[0] & 1) === 1;\r\n    };\r\n    SmallInteger.prototype.isOdd = function () {\r\n        return (this.value & 1) === 1;\r\n    };\r\n    NativeBigInt.prototype.isOdd = function () {\r\n        return (this.value & BigInt(1)) === BigInt(1);\r\n    }\r\n\r\n    BigInteger.prototype.isPositive = function () {\r\n        return !this.sign;\r\n    };\r\n    SmallInteger.prototype.isPositive = function () {\r\n        return this.value > 0;\r\n    };\r\n    NativeBigInt.prototype.isPositive = SmallInteger.prototype.isPositive;\r\n\r\n    BigInteger.prototype.isNegative = function () {\r\n        return this.sign;\r\n    };\r\n    SmallInteger.prototype.isNegative = function () {\r\n        return this.value < 0;\r\n    };\r\n    NativeBigInt.prototype.isNegative = SmallInteger.prototype.isNegative;\r\n\r\n    BigInteger.prototype.isUnit = function () {\r\n        return false;\r\n    };\r\n    SmallInteger.prototype.isUnit = function () {\r\n        return Math.abs(this.value) === 1;\r\n    };\r\n    NativeBigInt.prototype.isUnit = function () {\r\n        return this.abs().value === BigInt(1);\r\n    }\r\n\r\n    BigInteger.prototype.isZero = function () {\r\n        return false;\r\n    };\r\n    SmallInteger.prototype.isZero = function () {\r\n        return this.value === 0;\r\n    };\r\n    NativeBigInt.prototype.isZero = function () {\r\n        return this.value === BigInt(0);\r\n    }\r\n\r\n    BigInteger.prototype.isDivisibleBy = function (v) {\r\n        var n = parseValue(v);\r\n        if (n.isZero()) return false;\r\n        if (n.isUnit()) return true;\r\n        if (n.compareAbs(2) === 0) return this.isEven();\r\n        return this.mod(n).isZero();\r\n    };\r\n    NativeBigInt.prototype.isDivisibleBy = SmallInteger.prototype.isDivisibleBy = BigInteger.prototype.isDivisibleBy;\r\n\r\n    function isBasicPrime(v) {\r\n        var n = v.abs();\r\n        if (n.isUnit()) return false;\r\n        if (n.equals(2) || n.equals(3) || n.equals(5)) return true;\r\n        if (n.isEven() || n.isDivisibleBy(3) || n.isDivisibleBy(5)) return false;\r\n        if (n.lesser(49)) return true;\r\n        // we don't know if it's prime: let the other functions figure it out\r\n    }\r\n\r\n    function millerRabinTest(n, a) {\r\n        var nPrev = n.prev(),\r\n            b = nPrev,\r\n            r = 0,\r\n            d, t, i, x;\r\n        while (b.isEven()) b = b.divide(2), r++;\r\n        next: for (i = 0; i < a.length; i++) {\r\n            if (n.lesser(a[i])) continue;\r\n            x = bigInt(a[i]).modPow(b, n);\r\n            if (x.isUnit() || x.equals(nPrev)) continue;\r\n            for (d = r - 1; d != 0; d--) {\r\n                x = x.square().mod(n);\r\n                if (x.isUnit()) return false;\r\n                if (x.equals(nPrev)) continue next;\r\n            }\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n\r\n    // Set \"strict\" to true to force GRH-supported lower bound of 2*log(N)^2\r\n    BigInteger.prototype.isPrime = function (strict) {\r\n        var isPrime = isBasicPrime(this);\r\n        if (isPrime !== undefined) return isPrime;\r\n        var n = this.abs();\r\n        var bits = n.bitLength();\r\n        if (bits <= 64)\r\n            return millerRabinTest(n, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]);\r\n        var logN = Math.log(2) * bits.toJSNumber();\r\n        var t = Math.ceil((strict === true) ? (2 * Math.pow(logN, 2)) : logN);\r\n        for (var a = [], i = 0; i < t; i++) {\r\n            a.push(bigInt(i + 2));\r\n        }\r\n        return millerRabinTest(n, a);\r\n    };\r\n    NativeBigInt.prototype.isPrime = SmallInteger.prototype.isPrime = BigInteger.prototype.isPrime;\r\n\r\n    BigInteger.prototype.isProbablePrime = function (iterations, rng) {\r\n        var isPrime = isBasicPrime(this);\r\n        if (isPrime !== undefined) return isPrime;\r\n        var n = this.abs();\r\n        var t = iterations === undefined ? 5 : iterations;\r\n        for (var a = [], i = 0; i < t; i++) {\r\n            a.push(bigInt.randBetween(2, n.minus(2), rng));\r\n        }\r\n        return millerRabinTest(n, a);\r\n    };\r\n    NativeBigInt.prototype.isProbablePrime = SmallInteger.prototype.isProbablePrime = BigInteger.prototype.isProbablePrime;\r\n\r\n    BigInteger.prototype.modInv = function (n) {\r\n        var t = bigInt.zero, newT = bigInt.one, r = parseValue(n), newR = this.abs(), q, lastT, lastR;\r\n        while (!newR.isZero()) {\r\n            q = r.divide(newR);\r\n            lastT = t;\r\n            lastR = r;\r\n            t = newT;\r\n            r = newR;\r\n            newT = lastT.subtract(q.multiply(newT));\r\n            newR = lastR.subtract(q.multiply(newR));\r\n        }\r\n        if (!r.isUnit()) throw new Error(this.toString() + \" and \" + n.toString() + \" are not co-prime\");\r\n        if (t.compare(0) === -1) {\r\n            t = t.add(n);\r\n        }\r\n        if (this.isNegative()) {\r\n            return t.negate();\r\n        }\r\n        return t;\r\n    };\r\n\r\n    NativeBigInt.prototype.modInv = SmallInteger.prototype.modInv = BigInteger.prototype.modInv;\r\n\r\n    BigInteger.prototype.next = function () {\r\n        var value = this.value;\r\n        if (this.sign) {\r\n            return subtractSmall(value, 1, this.sign);\r\n        }\r\n        return new BigInteger(addSmall(value, 1), this.sign);\r\n    };\r\n    SmallInteger.prototype.next = function () {\r\n        var value = this.value;\r\n        if (value + 1 < MAX_INT) return new SmallInteger(value + 1);\r\n        return new BigInteger(MAX_INT_ARR, false);\r\n    };\r\n    NativeBigInt.prototype.next = function () {\r\n        return new NativeBigInt(this.value + BigInt(1));\r\n    }\r\n\r\n    BigInteger.prototype.prev = function () {\r\n        var value = this.value;\r\n        if (this.sign) {\r\n            return new BigInteger(addSmall(value, 1), true);\r\n        }\r\n        return subtractSmall(value, 1, this.sign);\r\n    };\r\n    SmallInteger.prototype.prev = function () {\r\n        var value = this.value;\r\n        if (value - 1 > -MAX_INT) return new SmallInteger(value - 1);\r\n        return new BigInteger(MAX_INT_ARR, true);\r\n    };\r\n    NativeBigInt.prototype.prev = function () {\r\n        return new NativeBigInt(this.value - BigInt(1));\r\n    }\r\n\r\n    var powersOfTwo = [1];\r\n    while (2 * powersOfTwo[powersOfTwo.length - 1] <= BASE) powersOfTwo.push(2 * powersOfTwo[powersOfTwo.length - 1]);\r\n    var powers2Length = powersOfTwo.length, highestPower2 = powersOfTwo[powers2Length - 1];\r\n\r\n    function shift_isSmall(n) {\r\n        return Math.abs(n) <= BASE;\r\n    }\r\n\r\n    BigInteger.prototype.shiftLeft = function (v) {\r\n        var n = parseValue(v).toJSNumber();\r\n        if (!shift_isSmall(n)) {\r\n            throw new Error(String(n) + \" is too large for shifting.\");\r\n        }\r\n        if (n < 0) return this.shiftRight(-n);\r\n        var result = this;\r\n        if (result.isZero()) return result;\r\n        while (n >= powers2Length) {\r\n            result = result.multiply(highestPower2);\r\n            n -= powers2Length - 1;\r\n        }\r\n        return result.multiply(powersOfTwo[n]);\r\n    };\r\n    NativeBigInt.prototype.shiftLeft = SmallInteger.prototype.shiftLeft = BigInteger.prototype.shiftLeft;\r\n\r\n    BigInteger.prototype.shiftRight = function (v) {\r\n        var remQuo;\r\n        var n = parseValue(v).toJSNumber();\r\n        if (!shift_isSmall(n)) {\r\n            throw new Error(String(n) + \" is too large for shifting.\");\r\n        }\r\n        if (n < 0) return this.shiftLeft(-n);\r\n        var result = this;\r\n        while (n >= powers2Length) {\r\n            if (result.isZero() || (result.isNegative() && result.isUnit())) return result;\r\n            remQuo = divModAny(result, highestPower2);\r\n            result = remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];\r\n            n -= powers2Length - 1;\r\n        }\r\n        remQuo = divModAny(result, powersOfTwo[n]);\r\n        return remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];\r\n    };\r\n    NativeBigInt.prototype.shiftRight = SmallInteger.prototype.shiftRight = BigInteger.prototype.shiftRight;\r\n\r\n    function bitwise(x, y, fn) {\r\n        y = parseValue(y);\r\n        var xSign = x.isNegative(), ySign = y.isNegative();\r\n        var xRem = xSign ? x.not() : x,\r\n            yRem = ySign ? y.not() : y;\r\n        var xDigit = 0, yDigit = 0;\r\n        var xDivMod = null, yDivMod = null;\r\n        var result = [];\r\n        while (!xRem.isZero() || !yRem.isZero()) {\r\n            xDivMod = divModAny(xRem, highestPower2);\r\n            xDigit = xDivMod[1].toJSNumber();\r\n            if (xSign) {\r\n                xDigit = highestPower2 - 1 - xDigit; // two's complement for negative numbers\r\n            }\r\n\r\n            yDivMod = divModAny(yRem, highestPower2);\r\n            yDigit = yDivMod[1].toJSNumber();\r\n            if (ySign) {\r\n                yDigit = highestPower2 - 1 - yDigit; // two's complement for negative numbers\r\n            }\r\n\r\n            xRem = xDivMod[0];\r\n            yRem = yDivMod[0];\r\n            result.push(fn(xDigit, yDigit));\r\n        }\r\n        var sum = fn(xSign ? 1 : 0, ySign ? 1 : 0) !== 0 ? bigInt(-1) : bigInt(0);\r\n        for (var i = result.length - 1; i >= 0; i -= 1) {\r\n            sum = sum.multiply(highestPower2).add(bigInt(result[i]));\r\n        }\r\n        return sum;\r\n    }\r\n\r\n    BigInteger.prototype.not = function () {\r\n        return this.negate().prev();\r\n    };\r\n    NativeBigInt.prototype.not = SmallInteger.prototype.not = BigInteger.prototype.not;\r\n\r\n    BigInteger.prototype.and = function (n) {\r\n        return bitwise(this, n, function (a, b) { return a & b; });\r\n    };\r\n    NativeBigInt.prototype.and = SmallInteger.prototype.and = BigInteger.prototype.and;\r\n\r\n    BigInteger.prototype.or = function (n) {\r\n        return bitwise(this, n, function (a, b) { return a | b; });\r\n    };\r\n    NativeBigInt.prototype.or = SmallInteger.prototype.or = BigInteger.prototype.or;\r\n\r\n    BigInteger.prototype.xor = function (n) {\r\n        return bitwise(this, n, function (a, b) { return a ^ b; });\r\n    };\r\n    NativeBigInt.prototype.xor = SmallInteger.prototype.xor = BigInteger.prototype.xor;\r\n\r\n    var LOBMASK_I = 1 << 30, LOBMASK_BI = (BASE & -BASE) * (BASE & -BASE) | LOBMASK_I;\r\n    function roughLOB(n) { // get lowestOneBit (rough)\r\n        // SmallInteger: return Min(lowestOneBit(n), 1 << 30)\r\n        // BigInteger: return Min(lowestOneBit(n), 1 << 14) [BASE=1e7]\r\n        var v = n.value,\r\n            x = typeof v === \"number\" ? v | LOBMASK_I :\r\n                typeof v === \"bigint\" ? v | BigInt(LOBMASK_I) :\r\n                    v[0] + v[1] * BASE | LOBMASK_BI;\r\n        return x & -x;\r\n    }\r\n\r\n    function integerLogarithm(value, base) {\r\n        if (base.compareTo(value) <= 0) {\r\n            var tmp = integerLogarithm(value, base.square(base));\r\n            var p = tmp.p;\r\n            var e = tmp.e;\r\n            var t = p.multiply(base);\r\n            return t.compareTo(value) <= 0 ? { p: t, e: e * 2 + 1 } : { p: p, e: e * 2 };\r\n        }\r\n        return { p: bigInt(1), e: 0 };\r\n    }\r\n\r\n    BigInteger.prototype.bitLength = function () {\r\n        var n = this;\r\n        if (n.compareTo(bigInt(0)) < 0) {\r\n            n = n.negate().subtract(bigInt(1));\r\n        }\r\n        if (n.compareTo(bigInt(0)) === 0) {\r\n            return bigInt(0);\r\n        }\r\n        return bigInt(integerLogarithm(n, bigInt(2)).e).add(bigInt(1));\r\n    }\r\n    NativeBigInt.prototype.bitLength = SmallInteger.prototype.bitLength = BigInteger.prototype.bitLength;\r\n\r\n    function max(a, b) {\r\n        a = parseValue(a);\r\n        b = parseValue(b);\r\n        return a.greater(b) ? a : b;\r\n    }\r\n    function min(a, b) {\r\n        a = parseValue(a);\r\n        b = parseValue(b);\r\n        return a.lesser(b) ? a : b;\r\n    }\r\n    function gcd(a, b) {\r\n        a = parseValue(a).abs();\r\n        b = parseValue(b).abs();\r\n        if (a.equals(b)) return a;\r\n        if (a.isZero()) return b;\r\n        if (b.isZero()) return a;\r\n        var c = Integer[1], d, t;\r\n        while (a.isEven() && b.isEven()) {\r\n            d = min(roughLOB(a), roughLOB(b));\r\n            a = a.divide(d);\r\n            b = b.divide(d);\r\n            c = c.multiply(d);\r\n        }\r\n        while (a.isEven()) {\r\n            a = a.divide(roughLOB(a));\r\n        }\r\n        do {\r\n            while (b.isEven()) {\r\n                b = b.divide(roughLOB(b));\r\n            }\r\n            if (a.greater(b)) {\r\n                t = b; b = a; a = t;\r\n            }\r\n            b = b.subtract(a);\r\n        } while (!b.isZero());\r\n        return c.isUnit() ? a : a.multiply(c);\r\n    }\r\n    function lcm(a, b) {\r\n        a = parseValue(a).abs();\r\n        b = parseValue(b).abs();\r\n        return a.divide(gcd(a, b)).multiply(b);\r\n    }\r\n    function randBetween(a, b, rng) {\r\n        a = parseValue(a);\r\n        b = parseValue(b);\r\n        var usedRNG = rng || Math.random;\r\n        var low = min(a, b), high = max(a, b);\r\n        var range = high.subtract(low).add(1);\r\n        if (range.isSmall) return low.add(Math.floor(usedRNG() * range));\r\n        var digits = toBase(range, BASE).value;\r\n        var result = [], restricted = true;\r\n        for (var i = 0; i < digits.length; i++) {\r\n            var top = restricted ? digits[i] + (i + 1 < digits.length ? digits[i + 1] / BASE : 0) : BASE;\r\n            var digit = truncate(usedRNG() * top);\r\n            result.push(digit);\r\n            if (digit < digits[i]) restricted = false;\r\n        }\r\n        return low.add(Integer.fromArray(result, BASE, false));\r\n    }\r\n\r\n    var parseBase = function (text, base, alphabet, caseSensitive) {\r\n        alphabet = alphabet || DEFAULT_ALPHABET;\r\n        text = String(text);\r\n        if (!caseSensitive) {\r\n            text = text.toLowerCase();\r\n            alphabet = alphabet.toLowerCase();\r\n        }\r\n        var length = text.length;\r\n        var i;\r\n        var absBase = Math.abs(base);\r\n        var alphabetValues = {};\r\n        for (i = 0; i < alphabet.length; i++) {\r\n            alphabetValues[alphabet[i]] = i;\r\n        }\r\n        for (i = 0; i < length; i++) {\r\n            var c = text[i];\r\n            if (c === \"-\") continue;\r\n            if (c in alphabetValues) {\r\n                if (alphabetValues[c] >= absBase) {\r\n                    if (c === \"1\" && absBase === 1) continue;\r\n                    throw new Error(c + \" is not a valid digit in base \" + base + \".\");\r\n                }\r\n            }\r\n        }\r\n        base = parseValue(base);\r\n        var digits = [];\r\n        var isNegative = text[0] === \"-\";\r\n        for (i = isNegative ? 1 : 0; i < text.length; i++) {\r\n            var c = text[i];\r\n            if (c in alphabetValues) digits.push(parseValue(alphabetValues[c]));\r\n            else if (c === \"<\") {\r\n                var start = i;\r\n                do { i++; } while (text[i] !== \">\" && i < text.length);\r\n                digits.push(parseValue(text.slice(start + 1, i)));\r\n            }\r\n            else throw new Error(c + \" is not a valid character\");\r\n        }\r\n        return parseBaseFromArray(digits, base, isNegative);\r\n    };\r\n\r\n    function parseBaseFromArray(digits, base, isNegative) {\r\n        var val = Integer[0], pow = Integer[1], i;\r\n        for (i = digits.length - 1; i >= 0; i--) {\r\n            val = val.add(digits[i].times(pow));\r\n            pow = pow.times(base);\r\n        }\r\n        return isNegative ? val.negate() : val;\r\n    }\r\n\r\n    function stringify(digit, alphabet) {\r\n        alphabet = alphabet || DEFAULT_ALPHABET;\r\n        if (digit < alphabet.length) {\r\n            return alphabet[digit];\r\n        }\r\n        return \"<\" + digit + \">\";\r\n    }\r\n\r\n    function toBase(n, base) {\r\n        base = bigInt(base);\r\n        if (base.isZero()) {\r\n            if (n.isZero()) return { value: [0], isNegative: false };\r\n            throw new Error(\"Cannot convert nonzero numbers to base 0.\");\r\n        }\r\n        if (base.equals(-1)) {\r\n            if (n.isZero()) return { value: [0], isNegative: false };\r\n            if (n.isNegative())\r\n                return {\r\n                    value: [].concat.apply([], Array.apply(null, Array(-n.toJSNumber()))\r\n                        .map(Array.prototype.valueOf, [1, 0])\r\n                    ),\r\n                    isNegative: false\r\n                };\r\n\r\n            var arr = Array.apply(null, Array(n.toJSNumber() - 1))\r\n                .map(Array.prototype.valueOf, [0, 1]);\r\n            arr.unshift([1]);\r\n            return {\r\n                value: [].concat.apply([], arr),\r\n                isNegative: false\r\n            };\r\n        }\r\n\r\n        var neg = false;\r\n        if (n.isNegative() && base.isPositive()) {\r\n            neg = true;\r\n            n = n.abs();\r\n        }\r\n        if (base.isUnit()) {\r\n            if (n.isZero()) return { value: [0], isNegative: false };\r\n\r\n            return {\r\n                value: Array.apply(null, Array(n.toJSNumber()))\r\n                    .map(Number.prototype.valueOf, 1),\r\n                isNegative: neg\r\n            };\r\n        }\r\n        var out = [];\r\n        var left = n, divmod;\r\n        while (left.isNegative() || left.compareAbs(base) >= 0) {\r\n            divmod = left.divmod(base);\r\n            left = divmod.quotient;\r\n            var digit = divmod.remainder;\r\n            if (digit.isNegative()) {\r\n                digit = base.minus(digit).abs();\r\n                left = left.next();\r\n            }\r\n            out.push(digit.toJSNumber());\r\n        }\r\n        out.push(left.toJSNumber());\r\n        return { value: out.reverse(), isNegative: neg };\r\n    }\r\n\r\n    function toBaseString(n, base, alphabet) {\r\n        var arr = toBase(n, base);\r\n        return (arr.isNegative ? \"-\" : \"\") + arr.value.map(function (x) {\r\n            return stringify(x, alphabet);\r\n        }).join('');\r\n    }\r\n\r\n    BigInteger.prototype.toArray = function (radix) {\r\n        return toBase(this, radix);\r\n    };\r\n\r\n    SmallInteger.prototype.toArray = function (radix) {\r\n        return toBase(this, radix);\r\n    };\r\n\r\n    NativeBigInt.prototype.toArray = function (radix) {\r\n        return toBase(this, radix);\r\n    };\r\n\r\n    BigInteger.prototype.toString = function (radix, alphabet) {\r\n        if (radix === undefined) radix = 10;\r\n        if (radix !== 10) return toBaseString(this, radix, alphabet);\r\n        var v = this.value, l = v.length, str = String(v[--l]), zeros = \"0000000\", digit;\r\n        while (--l >= 0) {\r\n            digit = String(v[l]);\r\n            str += zeros.slice(digit.length) + digit;\r\n        }\r\n        var sign = this.sign ? \"-\" : \"\";\r\n        return sign + str;\r\n    };\r\n\r\n    SmallInteger.prototype.toString = function (radix, alphabet) {\r\n        if (radix === undefined) radix = 10;\r\n        if (radix != 10) return toBaseString(this, radix, alphabet);\r\n        return String(this.value);\r\n    };\r\n\r\n    NativeBigInt.prototype.toString = SmallInteger.prototype.toString;\r\n\r\n    NativeBigInt.prototype.toJSON = BigInteger.prototype.toJSON = SmallInteger.prototype.toJSON = function () { return this.toString(); }\r\n\r\n    BigInteger.prototype.valueOf = function () {\r\n        return parseInt(this.toString(), 10);\r\n    };\r\n    BigInteger.prototype.toJSNumber = BigInteger.prototype.valueOf;\r\n\r\n    SmallInteger.prototype.valueOf = function () {\r\n        return this.value;\r\n    };\r\n    SmallInteger.prototype.toJSNumber = SmallInteger.prototype.valueOf;\r\n    NativeBigInt.prototype.valueOf = NativeBigInt.prototype.toJSNumber = function () {\r\n        return parseInt(this.toString(), 10);\r\n    }\r\n\r\n    function parseStringValue(v) {\r\n        if (isPrecise(+v)) {\r\n            var x = +v;\r\n            if (x === truncate(x))\r\n                return supportsNativeBigInt ? new NativeBigInt(BigInt(x)) : new SmallInteger(x);\r\n            throw new Error(\"Invalid integer: \" + v);\r\n        }\r\n        var sign = v[0] === \"-\";\r\n        if (sign) v = v.slice(1);\r\n        var split = v.split(/e/i);\r\n        if (split.length > 2) throw new Error(\"Invalid integer: \" + split.join(\"e\"));\r\n        if (split.length === 2) {\r\n            var exp = split[1];\r\n            if (exp[0] === \"+\") exp = exp.slice(1);\r\n            exp = +exp;\r\n            if (exp !== truncate(exp) || !isPrecise(exp)) throw new Error(\"Invalid integer: \" + exp + \" is not a valid exponent.\");\r\n            var text = split[0];\r\n            var decimalPlace = text.indexOf(\".\");\r\n            if (decimalPlace >= 0) {\r\n                exp -= text.length - decimalPlace - 1;\r\n                text = text.slice(0, decimalPlace) + text.slice(decimalPlace + 1);\r\n            }\r\n            if (exp < 0) throw new Error(\"Cannot include negative exponent part for integers\");\r\n            text += (new Array(exp + 1)).join(\"0\");\r\n            v = text;\r\n        }\r\n        var isValid = /^([0-9][0-9]*)$/.test(v);\r\n        if (!isValid) throw new Error(\"Invalid integer: \" + v);\r\n        if (supportsNativeBigInt) {\r\n            return new NativeBigInt(BigInt(sign ? \"-\" + v : v));\r\n        }\r\n        var r = [], max = v.length, l = LOG_BASE, min = max - l;\r\n        while (max > 0) {\r\n            r.push(+v.slice(min, max));\r\n            min -= l;\r\n            if (min < 0) min = 0;\r\n            max -= l;\r\n        }\r\n        trim(r);\r\n        return new BigInteger(r, sign);\r\n    }\r\n\r\n    function parseNumberValue(v) {\r\n        if (supportsNativeBigInt) {\r\n            return new NativeBigInt(BigInt(v));\r\n        }\r\n        if (isPrecise(v)) {\r\n            if (v !== truncate(v)) throw new Error(v + \" is not an integer.\");\r\n            return new SmallInteger(v);\r\n        }\r\n        return parseStringValue(v.toString());\r\n    }\r\n\r\n    function parseValue(v) {\r\n        if (typeof v === \"number\") {\r\n            return parseNumberValue(v);\r\n        }\r\n        if (typeof v === \"string\") {\r\n            return parseStringValue(v);\r\n        }\r\n        if (typeof v === \"bigint\") {\r\n            return new NativeBigInt(v);\r\n        }\r\n        return v;\r\n    }\r\n    // Pre-define numbers in range [-999,999]\r\n    for (var i = 0; i < 1000; i++) {\r\n        Integer[i] = parseValue(i);\r\n        if (i > 0) Integer[-i] = parseValue(-i);\r\n    }\r\n    // Backwards compatibility\r\n    Integer.one = Integer[1];\r\n    Integer.zero = Integer[0];\r\n    Integer.minusOne = Integer[-1];\r\n    Integer.max = max;\r\n    Integer.min = min;\r\n    Integer.gcd = gcd;\r\n    Integer.lcm = lcm;\r\n    Integer.isInstance = function (x) { return x instanceof BigInteger || x instanceof SmallInteger || x instanceof NativeBigInt; };\r\n    Integer.randBetween = randBetween;\r\n\r\n    Integer.fromArray = function (digits, base, isNegative) {\r\n        return parseBaseFromArray(digits.map(parseValue), parseValue(base || 10), isNegative);\r\n    };\r\n\r\n    return Integer;\r\n})();\r\n\r\n// Node.js check\r\nif (typeof module !== \"undefined\" && module.hasOwnProperty(\"exports\")) {\r\n    module.exports = bigInt;\r\n}\r\n\r\n//amd check\r\nif (typeof define === \"function\" && define.amd) {\r\n    define( function () {\r\n        return bigInt;\r\n    });\r\n}\r\n","(function (root) {\n\n/**********************************************************\n *\n * BitView\n *\n * BitView provides a similar interface to the standard\n * DataView, but with support for bit-level reads / writes.\n *\n **********************************************************/\nvar BitView = function (source, byteOffset, byteLength) {\n\tvar isBuffer = source instanceof ArrayBuffer ||\n\t\t(typeof Buffer !== 'undefined' && source instanceof Buffer);\n\n\tif (!isBuffer) {\n\t\tthrow new Error('Must specify a valid ArrayBuffer or Buffer.');\n\t}\n\n\tbyteOffset = byteOffset || 0;\n\tbyteLength = byteLength || source.byteLength /* ArrayBuffer */ || source.length /* Buffer */;\n\n\tthis._buffer = source;\n\tthis._view = new Uint8Array(this._buffer, byteOffset, byteLength);\n};\n\n// Used to massage fp values so we can operate on them\n// at the bit level.\nBitView._scratch = new DataView(new ArrayBuffer(8));\n\nObject.defineProperty(BitView.prototype, 'buffer', {\n\tget: function () { return this._buffer; },\n\tenumerable: true,\n\tconfigurable: false\n});\n\nObject.defineProperty(BitView.prototype, 'byteLength', {\n\tget: function () { return this._view.length; },\n\tenumerable: true,\n\tconfigurable: false\n});\n\nBitView.prototype._getBit = function (offset) {\n\treturn this._view[offset >> 3] >> (offset & 7) & 0x1;\n};\n\nBitView.prototype._setBit = function (offset, on) {\n\tif (on) {\n\t\tthis._view[offset >> 3] |= 1 << (offset & 7);\n\t} else {\n\t\tthis._view[offset >> 3] &= ~(1 << (offset & 7));\n\t}\n};\n\nBitView.prototype.getBits = function (offset, bits, signed) {\n\tvar available = (this._view.length * 8 - offset);\n\n\tif (bits > available) {\n\t\tthrow new Error('Cannot get ' + bits + ' bit(s) from offset ' + offset + ', ' + available + ' available');\n\t}\n\n\tvar value = 0;\n\tfor (var i = 0; i < bits;) {\n\t\tvar read;\n\n\t\t// Read an entire byte if we can.\n\t\tif ((bits - i) >= 8 && ((offset & 7) === 0)) {\n\t\t\tvalue |= (this._view[offset >> 3] << i);\n\t\t\tread = 8;\n\t\t} else {\n\t\t\tvalue |= (this._getBit(offset) << i);\n\t\t\tread = 1;\n\t\t}\n\n\t\toffset += read;\n\t\ti += read;\n\t}\n\n\tif (signed) {\n\t\t// If we're not working with a full 32 bits, check the\n\t\t// imaginary MSB for this bit count and convert to a\n\t\t// valid 32-bit signed value if set.\n\t\tif (bits !== 32 && value & (1 << (bits - 1))) {\n\t\t\tvalue |= -1 ^ ((1 << bits) - 1);\n\t\t}\n\n\t\treturn value;\n\t}\n\n\treturn value >>> 0;\n};\n\nBitView.prototype.setBits = function (offset, value, bits) {\n\tvar available = (this._view.length * 8 - offset);\n\n\tif (bits > available) {\n\t\tthrow new Error('Cannot set ' + bits + ' bit(s) from offset ' + offset + ', ' + available + ' available');\n\t}\n\n\tfor (var i = 0; i < bits;) {\n\t\tvar wrote;\n\n\t\t// Write an entire byte if we can.\n\t\tif ((bits - i) >= 8 && ((offset & 7) === 0)) {\n\t\t\tthis._view[offset >> 3] = value & 0xFF;\n\t\t\twrote = 8;\n\t\t} else {\n\t\t\tthis._setBit(offset, value & 0x1);\n\t\t\twrote = 1;\n\t\t}\n\n\t\tvalue = (value >> wrote);\n\n\t\toffset += wrote;\n\t\ti += wrote;\n\t}\n};\n\nBitView.prototype.getInt8 = function (offset) {\n\treturn this.getBits(offset, 8, true);\n};\nBitView.prototype.getUint8 = function (offset) {\n\treturn this.getBits(offset, 8, false);\n};\nBitView.prototype.getInt16 = function (offset) {\n\treturn this.getBits(offset, 16, true);\n};\nBitView.prototype.getUint16 = function (offset) {\n\treturn this.getBits(offset, 16, false);\n};\nBitView.prototype.getInt32 = function (offset) {\n\treturn this.getBits(offset, 32, true);\n};\nBitView.prototype.getUint32 = function (offset) {\n\treturn this.getBits(offset, 32, false);\n};\nBitView.prototype.getFloat32 = function (offset) {\n\tBitView._scratch.setUint32(0, this.getUint32(offset));\n\treturn BitView._scratch.getFloat32(0);\n};\nBitView.prototype.getFloat64 = function (offset) {\n\tBitView._scratch.setUint32(0, this.getUint32(offset));\n\t// DataView offset is in bytes.\n\tBitView._scratch.setUint32(4, this.getUint32(offset+32));\n\treturn BitView._scratch.getFloat64(0);\n};\n\nBitView.prototype.setInt8  =\nBitView.prototype.setUint8 = function (offset, value) {\n\tthis.setBits(offset, value, 8);\n};\nBitView.prototype.setInt16  =\nBitView.prototype.setUint16 = function (offset, value) {\n\tthis.setBits(offset, value, 16);\n};\nBitView.prototype.setInt32  =\nBitView.prototype.setUint32 = function (offset, value) {\n\tthis.setBits(offset, value, 32);\n};\nBitView.prototype.setFloat32 = function (offset, value) {\n\tBitView._scratch.setFloat32(0, value);\n\tthis.setBits(offset, BitView._scratch.getUint32(0), 32);\n};\nBitView.prototype.setFloat64 = function (offset, value) {\n\tBitView._scratch.setFloat64(0, value);\n\tthis.setBits(offset, BitView._scratch.getUint32(0), 32);\n\tthis.setBits(offset+32, BitView._scratch.getUint32(4), 32);\n};\n\n/**********************************************************\n *\n * BitStream\n *\n * Small wrapper for a BitView to maintain your position,\n * as well as to handle reading / writing of string data\n * to the underlying buffer.\n *\n **********************************************************/\nvar reader = function (name, size) {\n\treturn function () {\n\t\tvar val = this._view[name](this._index);\n\t\tthis._index += size;\n\t\treturn val;\n\t};\n};\n\nvar writer = function (name, size) {\n\treturn function (value) {\n\t\tthis._view[name](this._index, value);\n\t\tthis._index += size;\n\t};\n};\n\nfunction readASCIIString(stream, bytes) {\n\tvar i = 0;\n\tvar chars = [];\n\tvar append = true;\n\n\t// Read while we still have space available, or until we've\n\t// hit the fixed byte length passed in.\n\twhile (!bytes || (bytes && i < bytes)) {\n\t\tvar c = stream.readUint8();\n\n\t\t// Stop appending chars once we hit 0x00\n\t\tif (c === 0x00) {\n\t\t\tappend = false;\n\n\t\t\t// If we don't have a fixed length to read, break out now.\n\t\t\tif (!bytes) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tif (append) {\n\t\t\tchars.push(c);\n\t\t}\n\n\t\ti++;\n\t}\n\n\t// Convert char code array back to string.\n\treturn chars.map(function (x) {\n\t\treturn String.fromCharCode(x);\n\t}).join('');\n}\n\nfunction writeASCIIString(stream, string, bytes) {\n\tvar length = bytes || string.length + 1;  // + 1 for NULL\n\n\tfor (var i = 0; i < length; i++) {\n\t\tstream.writeUint8(i < string.length ? string.charCodeAt(i) : 0x00);\n\t}\n}\n\nvar BitStream = function (source, byteOffset, byteLength) {\n\tvar isBuffer = source instanceof ArrayBuffer ||\n\t\t(typeof Buffer !== 'undefined' && source instanceof Buffer);\n\n\tif (!(source instanceof BitView) && !isBuffer) {\n\t\tthrow new Error('Must specify a valid BitView, ArrayBuffer or Buffer');\n\t}\n\n\tif (isBuffer) {\n\t\tthis._view = new BitView(source, byteOffset, byteLength);\n\t} else {\n\t\tthis._view = source;\n\t}\n\n\tthis._index = 0;\n};\n\nObject.defineProperty(BitStream.prototype, 'byteIndex', {\n\t// Ceil the returned value, over compensating for the amount of\n\t// bits written to the stream.\n\tget: function () { return Math.ceil(this._index / 8); },\n\tset: function (val) { this._index = val * 8; },\n\tenumerable: true,\n\tconfigurable: true\n});\n\nObject.defineProperty(BitStream.prototype, 'buffer', {\n\tget: function () { return this._view.buffer; },\n\tenumerable: true,\n\tconfigurable: false\n});\n\nObject.defineProperty(BitStream.prototype, 'view', {\n\tget: function () { return this._view; },\n\tenumerable: true,\n\tconfigurable: false\n});\n\nBitStream.prototype.readBits = function (bits, signed) {\n\tvar val = this._view.getBits(this._index, bits, signed);\n\tthis._index += bits;\n\treturn val;\n};\n\nBitStream.prototype.writeBits = function (value, bits) {\n\tthis._view.setBits(this._index, value, bits);\n\tthis._index += bits;\n};\n\nBitStream.prototype.readInt8 = reader('getInt8', 8);\nBitStream.prototype.readUint8 = reader('getUint8', 8);\nBitStream.prototype.readInt16 = reader('getInt16', 16);\nBitStream.prototype.readUint16 = reader('getUint16', 16);\nBitStream.prototype.readInt32 = reader('getInt32', 32);\nBitStream.prototype.readUint32 = reader('getUint32', 32);\nBitStream.prototype.readFloat32 = reader('getFloat32', 32);\nBitStream.prototype.readFloat64 = reader('getFloat64', 64);\n\nBitStream.prototype.writeInt8 = writer('setInt8', 8);\nBitStream.prototype.writeUint8 = writer('setUint8', 8);\nBitStream.prototype.writeInt16 = writer('setInt16', 16);\nBitStream.prototype.writeUint16 = writer('setUint16', 16);\nBitStream.prototype.writeInt32 = writer('setInt32', 32);\nBitStream.prototype.writeUint32 = writer('setUint32', 32);\nBitStream.prototype.writeFloat32 = writer('setFloat32', 32);\nBitStream.prototype.writeFloat64 = writer('setFloat64', 64);\n\nBitStream.prototype.readASCIIString = function (bytes) {\n\treturn readASCIIString(this, bytes);\n};\n\nBitStream.prototype.writeASCIIString = function (string, bytes) {\n\twriteASCIIString(this, string, bytes);\n};\n\n// AMD / RequireJS\nif (typeof define !== 'undefined' && define.amd) {\n\tdefine(function () {\n\t\treturn {\n\t\t\tBitView: BitView,\n\t\t\tBitStream: BitStream\n\t\t};\n\t});\n}\n// Node.js\nelse if (typeof module !== 'undefined' && module.exports) {\n\tmodule.exports = {\n\t\tBitView: BitView,\n\t\tBitStream: BitStream\n\t};\n}\n\n}(this));","","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <https://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')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\nvar K_MAX_LENGTH = 0x7fffffff\nexports.kMaxLength = K_MAX_LENGTH\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Print warning and recommend using `buffer` v4.x which has an Object\n *               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 * We report that the browser does not support typed arrays if the are not subclassable\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\n * for __proto__ and has a buggy typed array implementation.\n */\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport()\n\nif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\n    typeof console.error === 'function') {\n  console.error(\n    'This browser lacks typed array (Uint8Array) support which is required by ' +\n    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\n  )\n}\n\nfunction typedArraySupport () {\n  // Can typed array instances can be augmented?\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } }\n    return arr.foo() === 42\n  } catch (e) {\n    return false\n  }\n}\n\nObject.defineProperty(Buffer.prototype, 'parent', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.buffer\n  }\n})\n\nObject.defineProperty(Buffer.prototype, 'offset', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.byteOffset\n  }\n})\n\nfunction createBuffer (length) {\n  if (length > K_MAX_LENGTH) {\n    throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"')\n  }\n  // Return an augmented `Uint8Array` instance\n  var buf = new Uint8Array(length)\n  buf.__proto__ = Buffer.prototype\n  return buf\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  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new TypeError(\n        'The \"string\" argument must be of type string. Received type number'\n      )\n    }\n    return allocUnsafe(arg)\n  }\n  return from(arg, encodingOrOffset, length)\n}\n\n// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\nif (typeof Symbol !== 'undefined' && Symbol.species != null &&\n    Buffer[Symbol.species] === Buffer) {\n  Object.defineProperty(Buffer, Symbol.species, {\n    value: null,\n    configurable: true,\n    enumerable: false,\n    writable: false\n  })\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\nfunction from (value, encodingOrOffset, length) {\n  if (typeof value === 'string') {\n    return fromString(value, encodingOrOffset)\n  }\n\n  if (ArrayBuffer.isView(value)) {\n    return fromArrayLike(value)\n  }\n\n  if (value == null) {\n    throw TypeError(\n      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n      'or Array-like Object. Received type ' + (typeof value)\n    )\n  }\n\n  if (isInstance(value, ArrayBuffer) ||\n      (value && isInstance(value.buffer, ArrayBuffer))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'number') {\n    throw new TypeError(\n      'The \"value\" argument must not be of type number. Received type number'\n    )\n  }\n\n  var valueOf = value.valueOf && value.valueOf()\n  if (valueOf != null && valueOf !== value) {\n    return Buffer.from(valueOf, encodingOrOffset, length)\n  }\n\n  var b = fromObject(value)\n  if (b) return b\n\n  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\n      typeof value[Symbol.toPrimitive] === 'function') {\n    return Buffer.from(\n      value[Symbol.toPrimitive]('string'), encodingOrOffset, length\n    )\n  }\n\n  throw new TypeError(\n    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n    'or Array-like Object. Received type ' + (typeof value)\n  )\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(value, encodingOrOffset, length)\n}\n\n// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\n// https://github.com/feross/buffer/pull/148\nBuffer.prototype.__proto__ = Uint8Array.prototype\nBuffer.__proto__ = Uint8Array\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be of type number')\n  } else if (size < 0) {\n    throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n  }\n}\n\nfunction alloc (size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(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(size).fill(fill, encoding)\n      : createBuffer(size).fill(fill)\n  }\n  return createBuffer(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(size, fill, encoding)\n}\n\nfunction allocUnsafe (size) {\n  assertSize(size)\n  return createBuffer(size < 0 ? 0 : checked(size) | 0)\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(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(size)\n}\n\nfunction fromString (string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('Unknown encoding: ' + encoding)\n  }\n\n  var length = byteLength(string, encoding) | 0\n  var buf = createBuffer(length)\n\n  var actual = buf.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    buf = buf.slice(0, actual)\n  }\n\n  return buf\n}\n\nfunction fromArrayLike (array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  var buf = createBuffer(length)\n  for (var i = 0; i < length; i += 1) {\n    buf[i] = array[i] & 255\n  }\n  return buf\n}\n\nfunction fromArrayBuffer (array, byteOffset, length) {\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\"offset\" is outside of buffer bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\"length\" is outside of buffer bounds')\n  }\n\n  var buf\n  if (byteOffset === undefined && length === undefined) {\n    buf = new Uint8Array(array)\n  } else if (length === undefined) {\n    buf = new Uint8Array(array, byteOffset)\n  } else {\n    buf = new Uint8Array(array, byteOffset, length)\n  }\n\n  // Return an augmented `Uint8Array` instance\n  buf.__proto__ = Buffer.prototype\n  return buf\n}\n\nfunction fromObject (obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    var buf = createBuffer(len)\n\n    if (buf.length === 0) {\n      return buf\n    }\n\n    obj.copy(buf, 0, 0, len)\n    return buf\n  }\n\n  if (obj.length !== undefined) {\n    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\n      return createBuffer(0)\n    }\n    return fromArrayLike(obj)\n  }\n\n  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\n    return fromArrayLike(obj.data)\n  }\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= K_MAX_LENGTH) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + K_MAX_LENGTH.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 === true &&\n    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\n}\n\nBuffer.compare = function compare (a, b) {\n  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)\n  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError(\n      'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n    )\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 (!Array.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 (isInstance(buf, Uint8Array)) {\n      buf = Buffer.from(buf)\n    }\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 (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    throw new TypeError(\n      'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\n      'Received type ' + typeof string\n    )\n  }\n\n  var len = string.length\n  var mustMatch = (arguments.length > 2 && arguments[2] === true)\n  if (!mustMatch && 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        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) {\n          return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\n        }\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// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\n// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\n// reliably in a browserify context because there could be multiple different\n// copies of the 'buffer' package in use. This method works even for Buffer\n// instances that were created from another copy of the `buffer` package.\n// See: https://github.com/feross/buffer/issues/154\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\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.toLocaleString = Buffer.prototype.toString\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  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()\n  if (this.length > max) str += ' ... '\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (isInstance(target, Uint8Array)) {\n    target = Buffer.from(target, target.offset, target.byteLength)\n  }\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError(\n      'The \"target\" argument must be one of type Buffer or Uint8Array. ' +\n      'Received type ' + (typeof target)\n    )\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 (numberIsNaN(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 (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  var strLen = string.length\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 (numberIsNaN(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  } 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 = this.subarray(start, end)\n  // Return an augmented `Uint8Array` instance\n  newBuf.__proto__ = Buffer.prototype\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  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  offset = offset >>> 0\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  this[offset] = (value & 0xff)\n  return offset + 1\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  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\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  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\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  this[offset + 3] = (value >>> 24)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 1] = (value >>> 8)\n  this[offset] = (value & 0xff)\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  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\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 (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  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\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  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\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  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 3] = (value >>> 24)\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  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\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  value = +value\n  offset = offset >>> 0\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  value = +value\n  offset = offset >>> 0\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 (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\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('Index out of range')\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\n  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {\n    // Use built-in when available, missing from IE11\n    this.copyWithin(targetStart, start, end)\n  } else if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (var i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, end),\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 (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    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if ((encoding === 'utf8' && code < 128) ||\n          encoding === 'latin1') {\n        // Fast path: If `val` fits into a single byte, use that numeric value.\n        val = code\n      }\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      : Buffer.from(val, encoding)\n    var len = bytes.length\n    if (len === 0) {\n      throw new TypeError('The value \"' + val +\n        '\" is invalid for argument \"value\"')\n    }\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 takes equal signs as end of the Base64 encoding\n  str = str.split('=')[0]\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = str.trim().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 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\n// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\n// the `instanceof` check but they should be treated as of that type.\n// See: https://github.com/feross/buffer/issues/166\nfunction isInstance (obj, type) {\n  return obj instanceof type ||\n    (obj != null && obj.constructor != null && obj.constructor.name != null &&\n      obj.constructor.name === type.name)\n}\nfunction numberIsNaN (obj) {\n  // For IE11 support\n  return obj !== obj // eslint-disable-line no-self-compare\n}\n","module.exports = {\n  \"100\": \"Continue\",\n  \"101\": \"Switching Protocols\",\n  \"102\": \"Processing\",\n  \"200\": \"OK\",\n  \"201\": \"Created\",\n  \"202\": \"Accepted\",\n  \"203\": \"Non-Authoritative Information\",\n  \"204\": \"No Content\",\n  \"205\": \"Reset Content\",\n  \"206\": \"Partial Content\",\n  \"207\": \"Multi-Status\",\n  \"208\": \"Already Reported\",\n  \"226\": \"IM Used\",\n  \"300\": \"Multiple Choices\",\n  \"301\": \"Moved Permanently\",\n  \"302\": \"Found\",\n  \"303\": \"See Other\",\n  \"304\": \"Not Modified\",\n  \"305\": \"Use Proxy\",\n  \"307\": \"Temporary Redirect\",\n  \"308\": \"Permanent Redirect\",\n  \"400\": \"Bad Request\",\n  \"401\": \"Unauthorized\",\n  \"402\": \"Payment Required\",\n  \"403\": \"Forbidden\",\n  \"404\": \"Not Found\",\n  \"405\": \"Method Not Allowed\",\n  \"406\": \"Not Acceptable\",\n  \"407\": \"Proxy Authentication Required\",\n  \"408\": \"Request Timeout\",\n  \"409\": \"Conflict\",\n  \"410\": \"Gone\",\n  \"411\": \"Length Required\",\n  \"412\": \"Precondition Failed\",\n  \"413\": \"Payload Too Large\",\n  \"414\": \"URI Too Long\",\n  \"415\": \"Unsupported Media Type\",\n  \"416\": \"Range Not Satisfiable\",\n  \"417\": \"Expectation Failed\",\n  \"418\": \"I'm a teapot\",\n  \"421\": \"Misdirected Request\",\n  \"422\": \"Unprocessable Entity\",\n  \"423\": \"Locked\",\n  \"424\": \"Failed Dependency\",\n  \"425\": \"Unordered Collection\",\n  \"426\": \"Upgrade Required\",\n  \"428\": \"Precondition Required\",\n  \"429\": \"Too Many Requests\",\n  \"431\": \"Request Header Fields Too Large\",\n  \"451\": \"Unavailable For Legal Reasons\",\n  \"500\": \"Internal Server Error\",\n  \"501\": \"Not Implemented\",\n  \"502\": \"Bad Gateway\",\n  \"503\": \"Service Unavailable\",\n  \"504\": \"Gateway Timeout\",\n  \"505\": \"HTTP Version Not Supported\",\n  \"506\": \"Variant Also Negotiates\",\n  \"507\": \"Insufficient Storage\",\n  \"508\": \"Loop Detected\",\n  \"509\": \"Bandwidth Limit Exceeded\",\n  \"510\": \"Not Extended\",\n  \"511\": \"Network Authentication Required\"\n}\n","/*\r\n Copyright 2013-2014 Daniel Wirtz <dcode@dcode.io>\r\n\r\n Licensed under the Apache License, Version 2.0 (the \"License\");\r\n you may not use this file except in compliance with the License.\r\n You may obtain a copy of the License at\r\n\r\n http://www.apache.org/licenses/LICENSE-2.0\r\n\r\n Unless required by applicable law or agreed to in writing, software\r\n distributed under the License is distributed on an \"AS IS\" BASIS,\r\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n See the License for the specific language governing permissions and\r\n limitations under the License.\r\n */\r\n\r\n/**\r\n * @license bytebuffer.js (c) 2015 Daniel Wirtz <dcode@dcode.io>\r\n * Backing buffer: ArrayBuffer, Accessor: Uint8Array\r\n * Released under the Apache License, Version 2.0\r\n * see: https://github.com/dcodeIO/bytebuffer.js for details\r\n */\r\n(function(global, factory) {\r\n\r\n    /* AMD */ if (typeof define === 'function' && define[\"amd\"])\r\n        define([\"long\"], factory);\r\n    /* CommonJS */ else if (typeof require === 'function' && typeof module === \"object\" && module && module[\"exports\"])\r\n        module['exports'] = (function() {\r\n            var Long; try { Long = require(\"long\"); } catch (e) {}\r\n            return factory(Long);\r\n        })();\r\n    /* Global */ else\r\n        (global[\"dcodeIO\"] = global[\"dcodeIO\"] || {})[\"ByteBuffer\"] = factory(global[\"dcodeIO\"][\"Long\"]);\r\n\r\n})(this, function(Long) {\r\n    \"use strict\";\r\n\r\n    /**\r\n     * Constructs a new ByteBuffer.\r\n     * @class The swiss army knife for binary data in JavaScript.\r\n     * @exports ByteBuffer\r\n     * @constructor\r\n     * @param {number=} capacity Initial capacity. Defaults to {@link ByteBuffer.DEFAULT_CAPACITY}.\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @expose\r\n     */\r\n    var ByteBuffer = function(capacity, littleEndian, noAssert) {\r\n        if (typeof capacity === 'undefined')\r\n            capacity = ByteBuffer.DEFAULT_CAPACITY;\r\n        if (typeof littleEndian === 'undefined')\r\n            littleEndian = ByteBuffer.DEFAULT_ENDIAN;\r\n        if (typeof noAssert === 'undefined')\r\n            noAssert = ByteBuffer.DEFAULT_NOASSERT;\r\n        if (!noAssert) {\r\n            capacity = capacity | 0;\r\n            if (capacity < 0)\r\n                throw RangeError(\"Illegal capacity\");\r\n            littleEndian = !!littleEndian;\r\n            noAssert = !!noAssert;\r\n        }\r\n\r\n        /**\r\n         * Backing ArrayBuffer.\r\n         * @type {!ArrayBuffer}\r\n         * @expose\r\n         */\r\n        this.buffer = capacity === 0 ? EMPTY_BUFFER : new ArrayBuffer(capacity);\r\n\r\n        /**\r\n         * Uint8Array utilized to manipulate the backing buffer. Becomes `null` if the backing buffer has a capacity of `0`.\r\n         * @type {?Uint8Array}\r\n         * @expose\r\n         */\r\n        this.view = capacity === 0 ? null : new Uint8Array(this.buffer);\r\n\r\n        /**\r\n         * Absolute read/write offset.\r\n         * @type {number}\r\n         * @expose\r\n         * @see ByteBuffer#flip\r\n         * @see ByteBuffer#clear\r\n         */\r\n        this.offset = 0;\r\n\r\n        /**\r\n         * Marked offset.\r\n         * @type {number}\r\n         * @expose\r\n         * @see ByteBuffer#mark\r\n         * @see ByteBuffer#reset\r\n         */\r\n        this.markedOffset = -1;\r\n\r\n        /**\r\n         * Absolute limit of the contained data. Set to the backing buffer's capacity upon allocation.\r\n         * @type {number}\r\n         * @expose\r\n         * @see ByteBuffer#flip\r\n         * @see ByteBuffer#clear\r\n         */\r\n        this.limit = capacity;\r\n\r\n        /**\r\n         * Whether to use little endian byte order, defaults to `false` for big endian.\r\n         * @type {boolean}\r\n         * @expose\r\n         */\r\n        this.littleEndian = littleEndian;\r\n\r\n        /**\r\n         * Whether to skip assertions of offsets and values, defaults to `false`.\r\n         * @type {boolean}\r\n         * @expose\r\n         */\r\n        this.noAssert = noAssert;\r\n    };\r\n\r\n    /**\r\n     * ByteBuffer version.\r\n     * @type {string}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.VERSION = \"5.0.1\";\r\n\r\n    /**\r\n     * Little endian constant that can be used instead of its boolean value. Evaluates to `true`.\r\n     * @type {boolean}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.LITTLE_ENDIAN = true;\r\n\r\n    /**\r\n     * Big endian constant that can be used instead of its boolean value. Evaluates to `false`.\r\n     * @type {boolean}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.BIG_ENDIAN = false;\r\n\r\n    /**\r\n     * Default initial capacity of `16`.\r\n     * @type {number}\r\n     * @expose\r\n     */\r\n    ByteBuffer.DEFAULT_CAPACITY = 16;\r\n\r\n    /**\r\n     * Default endianess of `false` for big endian.\r\n     * @type {boolean}\r\n     * @expose\r\n     */\r\n    ByteBuffer.DEFAULT_ENDIAN = ByteBuffer.BIG_ENDIAN;\r\n\r\n    /**\r\n     * Default no assertions flag of `false`.\r\n     * @type {boolean}\r\n     * @expose\r\n     */\r\n    ByteBuffer.DEFAULT_NOASSERT = false;\r\n\r\n    /**\r\n     * A `Long` class for representing a 64-bit two's-complement integer value. May be `null` if Long.js has not been loaded\r\n     *  and int64 support is not available.\r\n     * @type {?Long}\r\n     * @const\r\n     * @see https://github.com/dcodeIO/long.js\r\n     * @expose\r\n     */\r\n    ByteBuffer.Long = Long || null;\r\n\r\n    /**\r\n     * @alias ByteBuffer.prototype\r\n     * @inner\r\n     */\r\n    var ByteBufferPrototype = ByteBuffer.prototype;\r\n\r\n    /**\r\n     * An indicator used to reliably determine if an object is a ByteBuffer or not.\r\n     * @type {boolean}\r\n     * @const\r\n     * @expose\r\n     * @private\r\n     */\r\n    ByteBufferPrototype.__isByteBuffer__;\r\n\r\n    Object.defineProperty(ByteBufferPrototype, \"__isByteBuffer__\", {\r\n        value: true,\r\n        enumerable: false,\r\n        configurable: false\r\n    });\r\n\r\n    // helpers\r\n\r\n    /**\r\n     * @type {!ArrayBuffer}\r\n     * @inner\r\n     */\r\n    var EMPTY_BUFFER = new ArrayBuffer(0);\r\n\r\n    /**\r\n     * String.fromCharCode reference for compile-time renaming.\r\n     * @type {function(...number):string}\r\n     * @inner\r\n     */\r\n    var stringFromCharCode = String.fromCharCode;\r\n\r\n    /**\r\n     * Creates a source function for a string.\r\n     * @param {string} s String to read from\r\n     * @returns {function():number|null} Source function returning the next char code respectively `null` if there are\r\n     *  no more characters left.\r\n     * @throws {TypeError} If the argument is invalid\r\n     * @inner\r\n     */\r\n    function stringSource(s) {\r\n        var i=0; return function() {\r\n            return i < s.length ? s.charCodeAt(i++) : null;\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Creates a destination function for a string.\r\n     * @returns {function(number=):undefined|string} Destination function successively called with the next char code.\r\n     *  Returns the final string when called without arguments.\r\n     * @inner\r\n     */\r\n    function stringDestination() {\r\n        var cs = [], ps = []; return function() {\r\n            if (arguments.length === 0)\r\n                return ps.join('')+stringFromCharCode.apply(String, cs);\r\n            if (cs.length + arguments.length > 1024)\r\n                ps.push(stringFromCharCode.apply(String, cs)),\r\n                    cs.length = 0;\r\n            Array.prototype.push.apply(cs, arguments);\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Gets the accessor type.\r\n     * @returns {Function} `Buffer` under node.js, `Uint8Array` respectively `DataView` in the browser (classes)\r\n     * @expose\r\n     */\r\n    ByteBuffer.accessor = function() {\r\n        return Uint8Array;\r\n    };\r\n    /**\r\n     * Allocates a new ByteBuffer backed by a buffer of the specified capacity.\r\n     * @param {number=} capacity Initial capacity. Defaults to {@link ByteBuffer.DEFAULT_CAPACITY}.\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer}\r\n     * @expose\r\n     */\r\n    ByteBuffer.allocate = function(capacity, littleEndian, noAssert) {\r\n        return new ByteBuffer(capacity, littleEndian, noAssert);\r\n    };\r\n\r\n    /**\r\n     * Concatenates multiple ByteBuffers into one.\r\n     * @param {!Array.<!ByteBuffer|!ArrayBuffer|!Uint8Array|string>} buffers Buffers to concatenate\r\n     * @param {(string|boolean)=} encoding String encoding if `buffers` contains a string (\"base64\", \"hex\", \"binary\",\r\n     *  defaults to \"utf8\")\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order for the resulting ByteBuffer. Defaults\r\n     *  to {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values for the resulting ByteBuffer. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} Concatenated ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.concat = function(buffers, encoding, littleEndian, noAssert) {\r\n        if (typeof encoding === 'boolean' || typeof encoding !== 'string') {\r\n            noAssert = littleEndian;\r\n            littleEndian = encoding;\r\n            encoding = undefined;\r\n        }\r\n        var capacity = 0;\r\n        for (var i=0, k=buffers.length, length; i<k; ++i) {\r\n            if (!ByteBuffer.isByteBuffer(buffers[i]))\r\n                buffers[i] = ByteBuffer.wrap(buffers[i], encoding);\r\n            length = buffers[i].limit - buffers[i].offset;\r\n            if (length > 0) capacity += length;\r\n        }\r\n        if (capacity === 0)\r\n            return new ByteBuffer(0, littleEndian, noAssert);\r\n        var bb = new ByteBuffer(capacity, littleEndian, noAssert),\r\n            bi;\r\n        i=0; while (i<k) {\r\n            bi = buffers[i++];\r\n            length = bi.limit - bi.offset;\r\n            if (length <= 0) continue;\r\n            bb.view.set(bi.view.subarray(bi.offset, bi.limit), bb.offset);\r\n            bb.offset += length;\r\n        }\r\n        bb.limit = bb.offset;\r\n        bb.offset = 0;\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Tests if the specified type is a ByteBuffer.\r\n     * @param {*} bb ByteBuffer to test\r\n     * @returns {boolean} `true` if it is a ByteBuffer, otherwise `false`\r\n     * @expose\r\n     */\r\n    ByteBuffer.isByteBuffer = function(bb) {\r\n        return (bb && bb[\"__isByteBuffer__\"]) === true;\r\n    };\r\n    /**\r\n     * Gets the backing buffer type.\r\n     * @returns {Function} `Buffer` under node.js, `ArrayBuffer` in the browser (classes)\r\n     * @expose\r\n     */\r\n    ByteBuffer.type = function() {\r\n        return ArrayBuffer;\r\n    };\r\n    /**\r\n     * Wraps a buffer or a string. Sets the allocated ByteBuffer's {@link ByteBuffer#offset} to `0` and its\r\n     *  {@link ByteBuffer#limit} to the length of the wrapped data.\r\n     * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string|!Array.<number>} buffer Anything that can be wrapped\r\n     * @param {(string|boolean)=} encoding String encoding if `buffer` is a string (\"base64\", \"hex\", \"binary\", defaults to\r\n     *  \"utf8\")\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} A ByteBuffer wrapping `buffer`\r\n     * @expose\r\n     */\r\n    ByteBuffer.wrap = function(buffer, encoding, littleEndian, noAssert) {\r\n        if (typeof encoding !== 'string') {\r\n            noAssert = littleEndian;\r\n            littleEndian = encoding;\r\n            encoding = undefined;\r\n        }\r\n        if (typeof buffer === 'string') {\r\n            if (typeof encoding === 'undefined')\r\n                encoding = \"utf8\";\r\n            switch (encoding) {\r\n                case \"base64\":\r\n                    return ByteBuffer.fromBase64(buffer, littleEndian);\r\n                case \"hex\":\r\n                    return ByteBuffer.fromHex(buffer, littleEndian);\r\n                case \"binary\":\r\n                    return ByteBuffer.fromBinary(buffer, littleEndian);\r\n                case \"utf8\":\r\n                    return ByteBuffer.fromUTF8(buffer, littleEndian);\r\n                case \"debug\":\r\n                    return ByteBuffer.fromDebug(buffer, littleEndian);\r\n                default:\r\n                    throw Error(\"Unsupported encoding: \"+encoding);\r\n            }\r\n        }\r\n        if (buffer === null || typeof buffer !== 'object')\r\n            throw TypeError(\"Illegal buffer\");\r\n        var bb;\r\n        if (ByteBuffer.isByteBuffer(buffer)) {\r\n            bb = ByteBufferPrototype.clone.call(buffer);\r\n            bb.markedOffset = -1;\r\n            return bb;\r\n        }\r\n        if (buffer instanceof Uint8Array) { // Extract ArrayBuffer from Uint8Array\r\n            bb = new ByteBuffer(0, littleEndian, noAssert);\r\n            if (buffer.length > 0) { // Avoid references to more than one EMPTY_BUFFER\r\n                bb.buffer = buffer.buffer;\r\n                bb.offset = buffer.byteOffset;\r\n                bb.limit = buffer.byteOffset + buffer.byteLength;\r\n                bb.view = new Uint8Array(buffer.buffer);\r\n            }\r\n        } else if (buffer instanceof ArrayBuffer) { // Reuse ArrayBuffer\r\n            bb = new ByteBuffer(0, littleEndian, noAssert);\r\n            if (buffer.byteLength > 0) {\r\n                bb.buffer = buffer;\r\n                bb.offset = 0;\r\n                bb.limit = buffer.byteLength;\r\n                bb.view = buffer.byteLength > 0 ? new Uint8Array(buffer) : null;\r\n            }\r\n        } else if (Object.prototype.toString.call(buffer) === \"[object Array]\") { // Create from octets\r\n            bb = new ByteBuffer(buffer.length, littleEndian, noAssert);\r\n            bb.limit = buffer.length;\r\n            for (var i=0; i<buffer.length; ++i)\r\n                bb.view[i] = buffer[i];\r\n        } else\r\n            throw TypeError(\"Illegal buffer\"); // Otherwise fail\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Writes the array as a bitset.\r\n     * @param {Array<boolean>} value Array of booleans to write\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.\r\n     * @returns {!ByteBuffer}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeBitSet = function(value, offset) {\r\n      var relative = typeof offset === 'undefined';\n      if (relative) offset = this.offset;\n      if (!this.noAssert) {\r\n        if (!(value instanceof Array))\r\n          throw TypeError(\"Illegal BitSet: Not an array\");\r\n        if (typeof offset !== 'number' || offset % 1 !== 0)\n            throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n        offset >>>= 0;\n        if (offset < 0 || offset + 0 > this.buffer.byteLength)\n            throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n      }\r\n\r\n      var start = offset,\r\n          bits = value.length,\r\n          bytes = (bits >> 3),\r\n          bit = 0,\r\n          k;\r\n\r\n      offset += this.writeVarint32(bits,offset);\r\n\r\n      while(bytes--) {\r\n        k = (!!value[bit++] & 1) |\r\n            ((!!value[bit++] & 1) << 1) |\r\n            ((!!value[bit++] & 1) << 2) |\r\n            ((!!value[bit++] & 1) << 3) |\r\n            ((!!value[bit++] & 1) << 4) |\r\n            ((!!value[bit++] & 1) << 5) |\r\n            ((!!value[bit++] & 1) << 6) |\r\n            ((!!value[bit++] & 1) << 7);\r\n        this.writeByte(k,offset++);\r\n      }\r\n\r\n      if(bit < bits) {\r\n        var m = 0; k = 0;\r\n        while(bit < bits) k = k | ((!!value[bit++] & 1) << (m++));\r\n        this.writeByte(k,offset++);\r\n      }\r\n\r\n      if (relative) {\r\n        this.offset = offset;\r\n        return this;\r\n      }\r\n      return offset - start;\r\n    }\r\n\r\n    /**\r\n     * Reads a BitSet as an array of booleans.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.\r\n     * @returns {Array<boolean>\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readBitSet = function(offset) {\r\n      var relative = typeof offset === 'undefined';\n      if (relative) offset = this.offset;\n\r\n      var ret = this.readVarint32(offset),\r\n          bits = ret.value,\r\n          bytes = (bits >> 3),\r\n          bit = 0,\r\n          value = [],\r\n          k;\r\n\r\n      offset += ret.length;\r\n\r\n      while(bytes--) {\r\n        k = this.readByte(offset++);\r\n        value[bit++] = !!(k & 0x01);\r\n        value[bit++] = !!(k & 0x02);\r\n        value[bit++] = !!(k & 0x04);\r\n        value[bit++] = !!(k & 0x08);\r\n        value[bit++] = !!(k & 0x10);\r\n        value[bit++] = !!(k & 0x20);\r\n        value[bit++] = !!(k & 0x40);\r\n        value[bit++] = !!(k & 0x80);\r\n      }\r\n\r\n      if(bit < bits) {\r\n        var m = 0;\r\n        k = this.readByte(offset++);\r\n        while(bit < bits) value[bit++] = !!((k >> (m++)) & 1);\r\n      }\r\n\r\n      if (relative) {\r\n        this.offset = offset;\r\n      }\r\n      return value;\r\n    }\r\n    /**\r\n     * Reads the specified number of bytes.\r\n     * @param {number} length Number of bytes to read\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.\r\n     * @returns {!ByteBuffer}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readBytes = function(length, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + length > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+length+\") <= \"+this.buffer.byteLength);\n        }\r\n        var slice = this.slice(offset, offset + length);\r\n        if (relative) this.offset += length;\n        return slice;\r\n    };\r\n\r\n    /**\r\n     * Writes a payload of bytes. This is an alias of {@link ByteBuffer#append}.\r\n     * @function\r\n     * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string} source Data to write. If `source` is a ByteBuffer, its offsets\r\n     *  will be modified according to the performed read operation.\r\n     * @param {(string|number)=} encoding Encoding if `data` is a string (\"base64\", \"hex\", \"binary\", defaults to \"utf8\")\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeBytes = ByteBufferPrototype.append;\r\n\r\n    // types/ints/int8\r\n\r\n    /**\r\n     * Writes an 8bit signed integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeInt8 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 1;\n        var capacity0 = this.buffer.byteLength;\n        if (offset > capacity0)\n            this.resize((capacity0 *= 2) > offset ? capacity0 : offset);\n        offset -= 1;\n        this.view[offset] = value;\r\n        if (relative) this.offset += 1;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes an 8bit signed integer. This is an alias of {@link ByteBuffer#writeInt8}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeByte = ByteBufferPrototype.writeInt8;\r\n\r\n    /**\r\n     * Reads an 8bit signed integer.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readInt8 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = this.view[offset];\r\n        if ((value & 0x80) === 0x80) value = -(0xFF - value + 1); // Cast to signed\r\n        if (relative) this.offset += 1;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads an 8bit signed integer. This is an alias of {@link ByteBuffer#readInt8}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readByte = ByteBufferPrototype.readInt8;\r\n\r\n    /**\r\n     * Writes an 8bit unsigned integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUint8 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value >>>= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 1;\n        var capacity1 = this.buffer.byteLength;\n        if (offset > capacity1)\n            this.resize((capacity1 *= 2) > offset ? capacity1 : offset);\n        offset -= 1;\n        this.view[offset] = value;\r\n        if (relative) this.offset += 1;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes an 8bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint8}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUInt8 = ByteBufferPrototype.writeUint8;\r\n\r\n    /**\r\n     * Reads an 8bit unsigned integer.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUint8 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = this.view[offset];\r\n        if (relative) this.offset += 1;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads an 8bit unsigned integer. This is an alias of {@link ByteBuffer#readUint8}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUInt8 = ByteBufferPrototype.readUint8;\r\n\r\n    // types/ints/int16\r\n\r\n    /**\r\n     * Writes a 16bit signed integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @throws {TypeError} If `offset` or `value` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeInt16 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 2;\n        var capacity2 = this.buffer.byteLength;\n        if (offset > capacity2)\n            this.resize((capacity2 *= 2) > offset ? capacity2 : offset);\n        offset -= 2;\n        if (this.littleEndian) {\r\n            this.view[offset+1] = (value & 0xFF00) >>> 8;\r\n            this.view[offset  ] =  value & 0x00FF;\r\n        } else {\r\n            this.view[offset]   = (value & 0xFF00) >>> 8;\r\n            this.view[offset+1] =  value & 0x00FF;\r\n        }\r\n        if (relative) this.offset += 2;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 16bit signed integer. This is an alias of {@link ByteBuffer#writeInt16}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @throws {TypeError} If `offset` or `value` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeShort = ByteBufferPrototype.writeInt16;\r\n\r\n    /**\r\n     * Reads a 16bit signed integer.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @returns {number} Value read\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readInt16 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 2 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+2+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = 0;\r\n        if (this.littleEndian) {\r\n            value  = this.view[offset  ];\r\n            value |= this.view[offset+1] << 8;\r\n        } else {\r\n            value  = this.view[offset  ] << 8;\r\n            value |= this.view[offset+1];\r\n        }\r\n        if ((value & 0x8000) === 0x8000) value = -(0xFFFF - value + 1); // Cast to signed\r\n        if (relative) this.offset += 2;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 16bit signed integer. This is an alias of {@link ByteBuffer#readInt16}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @returns {number} Value read\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readShort = ByteBufferPrototype.readInt16;\r\n\r\n    /**\r\n     * Writes a 16bit unsigned integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @throws {TypeError} If `offset` or `value` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUint16 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value >>>= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 2;\n        var capacity3 = this.buffer.byteLength;\n        if (offset > capacity3)\n            this.resize((capacity3 *= 2) > offset ? capacity3 : offset);\n        offset -= 2;\n        if (this.littleEndian) {\r\n            this.view[offset+1] = (value & 0xFF00) >>> 8;\r\n            this.view[offset  ] =  value & 0x00FF;\r\n        } else {\r\n            this.view[offset]   = (value & 0xFF00) >>> 8;\r\n            this.view[offset+1] =  value & 0x00FF;\r\n        }\r\n        if (relative) this.offset += 2;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 16bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint16}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @throws {TypeError} If `offset` or `value` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUInt16 = ByteBufferPrototype.writeUint16;\r\n\r\n    /**\r\n     * Reads a 16bit unsigned integer.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @returns {number} Value read\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUint16 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 2 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+2+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = 0;\r\n        if (this.littleEndian) {\r\n            value  = this.view[offset  ];\r\n            value |= this.view[offset+1] << 8;\r\n        } else {\r\n            value  = this.view[offset  ] << 8;\r\n            value |= this.view[offset+1];\r\n        }\r\n        if (relative) this.offset += 2;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 16bit unsigned integer. This is an alias of {@link ByteBuffer#readUint16}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.\r\n     * @returns {number} Value read\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUInt16 = ByteBufferPrototype.readUint16;\r\n\r\n    // types/ints/int32\r\n\r\n    /**\r\n     * Writes a 32bit signed integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeInt32 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 4;\n        var capacity4 = this.buffer.byteLength;\n        if (offset > capacity4)\n            this.resize((capacity4 *= 2) > offset ? capacity4 : offset);\n        offset -= 4;\n        if (this.littleEndian) {\n            this.view[offset+3] = (value >>> 24) & 0xFF;\n            this.view[offset+2] = (value >>> 16) & 0xFF;\n            this.view[offset+1] = (value >>>  8) & 0xFF;\n            this.view[offset  ] =  value         & 0xFF;\n        } else {\n            this.view[offset  ] = (value >>> 24) & 0xFF;\n            this.view[offset+1] = (value >>> 16) & 0xFF;\n            this.view[offset+2] = (value >>>  8) & 0xFF;\n            this.view[offset+3] =  value         & 0xFF;\n        }\n        if (relative) this.offset += 4;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 32bit signed integer. This is an alias of {@link ByteBuffer#writeInt32}.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeInt = ByteBufferPrototype.writeInt32;\r\n\r\n    /**\r\n     * Reads a 32bit signed integer.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readInt32 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 4 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+4+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = 0;\r\n        if (this.littleEndian) {\n            value  = this.view[offset+2] << 16;\n            value |= this.view[offset+1] <<  8;\n            value |= this.view[offset  ];\n            value += this.view[offset+3] << 24 >>> 0;\n        } else {\n            value  = this.view[offset+1] << 16;\n            value |= this.view[offset+2] <<  8;\n            value |= this.view[offset+3];\n            value += this.view[offset  ] << 24 >>> 0;\n        }\n        value |= 0; // Cast to signed\r\n        if (relative) this.offset += 4;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 32bit signed integer. This is an alias of {@link ByteBuffer#readInt32}.\r\n     * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readInt = ByteBufferPrototype.readInt32;\r\n\r\n    /**\r\n     * Writes a 32bit unsigned integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUint32 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value >>>= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 4;\n        var capacity5 = this.buffer.byteLength;\n        if (offset > capacity5)\n            this.resize((capacity5 *= 2) > offset ? capacity5 : offset);\n        offset -= 4;\n        if (this.littleEndian) {\n            this.view[offset+3] = (value >>> 24) & 0xFF;\n            this.view[offset+2] = (value >>> 16) & 0xFF;\n            this.view[offset+1] = (value >>>  8) & 0xFF;\n            this.view[offset  ] =  value         & 0xFF;\n        } else {\n            this.view[offset  ] = (value >>> 24) & 0xFF;\n            this.view[offset+1] = (value >>> 16) & 0xFF;\n            this.view[offset+2] = (value >>>  8) & 0xFF;\n            this.view[offset+3] =  value         & 0xFF;\n        }\n        if (relative) this.offset += 4;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 32bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint32}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUInt32 = ByteBufferPrototype.writeUint32;\r\n\r\n    /**\r\n     * Reads a 32bit unsigned integer.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUint32 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 4 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+4+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = 0;\r\n        if (this.littleEndian) {\n            value  = this.view[offset+2] << 16;\n            value |= this.view[offset+1] <<  8;\n            value |= this.view[offset  ];\n            value += this.view[offset+3] << 24 >>> 0;\n        } else {\n            value  = this.view[offset+1] << 16;\n            value |= this.view[offset+2] <<  8;\n            value |= this.view[offset+3];\n            value += this.view[offset  ] << 24 >>> 0;\n        }\n        if (relative) this.offset += 4;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 32bit unsigned integer. This is an alias of {@link ByteBuffer#readUint32}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number} Value read\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUInt32 = ByteBufferPrototype.readUint32;\r\n\r\n    // types/ints/int64\r\n\r\n    if (Long) {\r\n\r\n        /**\r\n         * Writes a 64bit signed integer.\r\n         * @param {number|!Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!ByteBuffer} this\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeInt64 = function(value, offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof value === 'number')\n                    value = Long.fromNumber(value);\n                else if (typeof value === 'string')\n                    value = Long.fromString(value);\n                else if (!(value && value instanceof Long))\n                    throw TypeError(\"Illegal value: \"+value+\" (not an integer or Long)\");\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n            }\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value);\n            else if (typeof value === 'string')\n                value = Long.fromString(value);\n            offset += 8;\n            var capacity6 = this.buffer.byteLength;\n            if (offset > capacity6)\n                this.resize((capacity6 *= 2) > offset ? capacity6 : offset);\n            offset -= 8;\n            var lo = value.low,\r\n                hi = value.high;\r\n            if (this.littleEndian) {\r\n                this.view[offset+3] = (lo >>> 24) & 0xFF;\n                this.view[offset+2] = (lo >>> 16) & 0xFF;\n                this.view[offset+1] = (lo >>>  8) & 0xFF;\n                this.view[offset  ] =  lo         & 0xFF;\n                offset += 4;\r\n                this.view[offset+3] = (hi >>> 24) & 0xFF;\n                this.view[offset+2] = (hi >>> 16) & 0xFF;\n                this.view[offset+1] = (hi >>>  8) & 0xFF;\n                this.view[offset  ] =  hi         & 0xFF;\n            } else {\r\n                this.view[offset  ] = (hi >>> 24) & 0xFF;\n                this.view[offset+1] = (hi >>> 16) & 0xFF;\n                this.view[offset+2] = (hi >>>  8) & 0xFF;\n                this.view[offset+3] =  hi         & 0xFF;\n                offset += 4;\r\n                this.view[offset  ] = (lo >>> 24) & 0xFF;\n                this.view[offset+1] = (lo >>> 16) & 0xFF;\n                this.view[offset+2] = (lo >>>  8) & 0xFF;\n                this.view[offset+3] =  lo         & 0xFF;\n            }\r\n            if (relative) this.offset += 8;\n            return this;\r\n        };\r\n\r\n        /**\r\n         * Writes a 64bit signed integer. This is an alias of {@link ByteBuffer#writeInt64}.\r\n         * @param {number|!Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!ByteBuffer} this\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeLong = ByteBufferPrototype.writeInt64;\r\n\r\n        /**\r\n         * Reads a 64bit signed integer.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!Long}\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readInt64 = function(offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 8 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+8+\") <= \"+this.buffer.byteLength);\n            }\r\n            var lo = 0,\r\n                hi = 0;\r\n            if (this.littleEndian) {\r\n                lo  = this.view[offset+2] << 16;\n                lo |= this.view[offset+1] <<  8;\n                lo |= this.view[offset  ];\n                lo += this.view[offset+3] << 24 >>> 0;\n                offset += 4;\r\n                hi  = this.view[offset+2] << 16;\n                hi |= this.view[offset+1] <<  8;\n                hi |= this.view[offset  ];\n                hi += this.view[offset+3] << 24 >>> 0;\n            } else {\r\n                hi  = this.view[offset+1] << 16;\n                hi |= this.view[offset+2] <<  8;\n                hi |= this.view[offset+3];\n                hi += this.view[offset  ] << 24 >>> 0;\n                offset += 4;\r\n                lo  = this.view[offset+1] << 16;\n                lo |= this.view[offset+2] <<  8;\n                lo |= this.view[offset+3];\n                lo += this.view[offset  ] << 24 >>> 0;\n            }\r\n            var value = new Long(lo, hi, false);\r\n            if (relative) this.offset += 8;\n            return value;\r\n        };\r\n\r\n        /**\r\n         * Reads a 64bit signed integer. This is an alias of {@link ByteBuffer#readInt64}.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!Long}\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readLong = ByteBufferPrototype.readInt64;\r\n\r\n        /**\r\n         * Writes a 64bit unsigned integer.\r\n         * @param {number|!Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!ByteBuffer} this\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeUint64 = function(value, offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof value === 'number')\n                    value = Long.fromNumber(value);\n                else if (typeof value === 'string')\n                    value = Long.fromString(value);\n                else if (!(value && value instanceof Long))\n                    throw TypeError(\"Illegal value: \"+value+\" (not an integer or Long)\");\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n            }\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value);\n            else if (typeof value === 'string')\n                value = Long.fromString(value);\n            offset += 8;\n            var capacity7 = this.buffer.byteLength;\n            if (offset > capacity7)\n                this.resize((capacity7 *= 2) > offset ? capacity7 : offset);\n            offset -= 8;\n            var lo = value.low,\r\n                hi = value.high;\r\n            if (this.littleEndian) {\r\n                this.view[offset+3] = (lo >>> 24) & 0xFF;\n                this.view[offset+2] = (lo >>> 16) & 0xFF;\n                this.view[offset+1] = (lo >>>  8) & 0xFF;\n                this.view[offset  ] =  lo         & 0xFF;\n                offset += 4;\r\n                this.view[offset+3] = (hi >>> 24) & 0xFF;\n                this.view[offset+2] = (hi >>> 16) & 0xFF;\n                this.view[offset+1] = (hi >>>  8) & 0xFF;\n                this.view[offset  ] =  hi         & 0xFF;\n            } else {\r\n                this.view[offset  ] = (hi >>> 24) & 0xFF;\n                this.view[offset+1] = (hi >>> 16) & 0xFF;\n                this.view[offset+2] = (hi >>>  8) & 0xFF;\n                this.view[offset+3] =  hi         & 0xFF;\n                offset += 4;\r\n                this.view[offset  ] = (lo >>> 24) & 0xFF;\n                this.view[offset+1] = (lo >>> 16) & 0xFF;\n                this.view[offset+2] = (lo >>>  8) & 0xFF;\n                this.view[offset+3] =  lo         & 0xFF;\n            }\r\n            if (relative) this.offset += 8;\n            return this;\r\n        };\r\n\r\n        /**\r\n         * Writes a 64bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint64}.\r\n         * @function\r\n         * @param {number|!Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!ByteBuffer} this\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeUInt64 = ByteBufferPrototype.writeUint64;\r\n\r\n        /**\r\n         * Reads a 64bit unsigned integer.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!Long}\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readUint64 = function(offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 8 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+8+\") <= \"+this.buffer.byteLength);\n            }\r\n            var lo = 0,\r\n                hi = 0;\r\n            if (this.littleEndian) {\r\n                lo  = this.view[offset+2] << 16;\n                lo |= this.view[offset+1] <<  8;\n                lo |= this.view[offset  ];\n                lo += this.view[offset+3] << 24 >>> 0;\n                offset += 4;\r\n                hi  = this.view[offset+2] << 16;\n                hi |= this.view[offset+1] <<  8;\n                hi |= this.view[offset  ];\n                hi += this.view[offset+3] << 24 >>> 0;\n            } else {\r\n                hi  = this.view[offset+1] << 16;\n                hi |= this.view[offset+2] <<  8;\n                hi |= this.view[offset+3];\n                hi += this.view[offset  ] << 24 >>> 0;\n                offset += 4;\r\n                lo  = this.view[offset+1] << 16;\n                lo |= this.view[offset+2] <<  8;\n                lo |= this.view[offset+3];\n                lo += this.view[offset  ] << 24 >>> 0;\n            }\r\n            var value = new Long(lo, hi, true);\r\n            if (relative) this.offset += 8;\n            return value;\r\n        };\r\n\r\n        /**\r\n         * Reads a 64bit unsigned integer. This is an alias of {@link ByteBuffer#readUint64}.\r\n         * @function\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n         * @returns {!Long}\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readUInt64 = ByteBufferPrototype.readUint64;\r\n\r\n    } // Long\r\n\r\n\r\n    // types/floats/float32\r\n\r\n    /*\r\n     ieee754 - https://github.com/feross/ieee754\r\n\r\n     The MIT License (MIT)\r\n\r\n     Copyright (c) Feross Aboukhadijeh\r\n\r\n     Permission is hereby granted, free of charge, to any person obtaining a copy\r\n     of this software and associated documentation files (the \"Software\"), to deal\r\n     in the Software without restriction, including without limitation the rights\r\n     to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n     copies of the Software, and to permit persons to whom the Software is\r\n     furnished to do so, subject to the following conditions:\r\n\r\n     The above copyright notice and this permission notice shall be included in\r\n     all copies or substantial portions of the Software.\r\n\r\n     THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n     IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n     AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r\n     THE SOFTWARE.\r\n    */\r\n\r\n    /**\r\n     * Reads an IEEE754 float from a byte array.\r\n     * @param {!Array} buffer\r\n     * @param {number} offset\r\n     * @param {boolean} isLE\r\n     * @param {number} mLen\r\n     * @param {number} nBytes\r\n     * @returns {number}\r\n     * @inner\r\n     */\r\n    function ieee754_read(buffer, offset, isLE, mLen, nBytes) {\r\n        var e, m,\r\n            eLen = nBytes * 8 - mLen - 1,\r\n            eMax = (1 << eLen) - 1,\r\n            eBias = eMax >> 1,\r\n            nBits = -7,\r\n            i = isLE ? (nBytes - 1) : 0,\r\n            d = isLE ? -1 : 1,\r\n            s = buffer[offset + i];\r\n\r\n        i += d;\r\n\r\n        e = s & ((1 << (-nBits)) - 1);\r\n        s >>= (-nBits);\r\n        nBits += eLen;\r\n        for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}\r\n\r\n        m = e & ((1 << (-nBits)) - 1);\r\n        e >>= (-nBits);\r\n        nBits += mLen;\r\n        for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}\r\n\r\n        if (e === 0) {\r\n            e = 1 - eBias;\r\n        } else if (e === eMax) {\r\n            return m ? NaN : ((s ? -1 : 1) * Infinity);\r\n        } else {\r\n            m = m + Math.pow(2, mLen);\r\n            e = e - eBias;\r\n        }\r\n        return (s ? -1 : 1) * m * Math.pow(2, e - mLen);\r\n    }\r\n\r\n    /**\r\n     * Writes an IEEE754 float to a byte array.\r\n     * @param {!Array} buffer\r\n     * @param {number} value\r\n     * @param {number} offset\r\n     * @param {boolean} isLE\r\n     * @param {number} mLen\r\n     * @param {number} nBytes\r\n     * @inner\r\n     */\r\n    function ieee754_write(buffer, value, offset, isLE, mLen, nBytes) {\r\n        var e, m, c,\r\n            eLen = nBytes * 8 - mLen - 1,\r\n            eMax = (1 << eLen) - 1,\r\n            eBias = eMax >> 1,\r\n            rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),\r\n            i = isLE ? 0 : (nBytes - 1),\r\n            d = isLE ? 1 : -1,\r\n            s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;\r\n\r\n        value = Math.abs(value);\r\n\r\n        if (isNaN(value) || value === Infinity) {\r\n            m = isNaN(value) ? 1 : 0;\r\n            e = eMax;\r\n        } else {\r\n            e = Math.floor(Math.log(value) / Math.LN2);\r\n            if (value * (c = Math.pow(2, -e)) < 1) {\r\n                e--;\r\n                c *= 2;\r\n            }\r\n            if (e + eBias >= 1) {\r\n                value += rt / c;\r\n            } else {\r\n                value += rt * Math.pow(2, 1 - eBias);\r\n            }\r\n            if (value * c >= 2) {\r\n                e++;\r\n                c /= 2;\r\n            }\r\n\r\n            if (e + eBias >= eMax) {\r\n                m = 0;\r\n                e = eMax;\r\n            } else if (e + eBias >= 1) {\r\n                m = (value * c - 1) * Math.pow(2, mLen);\r\n                e = e + eBias;\r\n            } else {\r\n                m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\r\n                e = 0;\r\n            }\r\n        }\r\n\r\n        for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\r\n\r\n        e = (e << mLen) | m;\r\n        eLen += mLen;\r\n        for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\r\n\r\n        buffer[offset + i - d] |= s * 128;\r\n    }\r\n\r\n    /**\r\n     * Writes a 32bit float.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeFloat32 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number')\r\n                throw TypeError(\"Illegal value: \"+value+\" (not a number)\");\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 4;\n        var capacity8 = this.buffer.byteLength;\n        if (offset > capacity8)\n            this.resize((capacity8 *= 2) > offset ? capacity8 : offset);\n        offset -= 4;\n        ieee754_write(this.view, value, offset, this.littleEndian, 23, 4);\r\n        if (relative) this.offset += 4;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 32bit float. This is an alias of {@link ByteBuffer#writeFloat32}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeFloat = ByteBufferPrototype.writeFloat32;\r\n\r\n    /**\r\n     * Reads a 32bit float.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readFloat32 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 4 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+4+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = ieee754_read(this.view, offset, this.littleEndian, 23, 4);\r\n        if (relative) this.offset += 4;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 32bit float. This is an alias of {@link ByteBuffer#readFloat32}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.\r\n     * @returns {number}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readFloat = ByteBufferPrototype.readFloat32;\r\n\r\n    // types/floats/float64\r\n\r\n    /**\r\n     * Writes a 64bit float.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeFloat64 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number')\r\n                throw TypeError(\"Illegal value: \"+value+\" (not a number)\");\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        offset += 8;\n        var capacity9 = this.buffer.byteLength;\n        if (offset > capacity9)\n            this.resize((capacity9 *= 2) > offset ? capacity9 : offset);\n        offset -= 8;\n        ieee754_write(this.view, value, offset, this.littleEndian, 52, 8);\r\n        if (relative) this.offset += 8;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Writes a 64bit float. This is an alias of {@link ByteBuffer#writeFloat64}.\r\n     * @function\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeDouble = ByteBufferPrototype.writeFloat64;\r\n\r\n    /**\r\n     * Reads a 64bit float.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n     * @returns {number}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readFloat64 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 8 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+8+\") <= \"+this.buffer.byteLength);\n        }\r\n        var value = ieee754_read(this.view, offset, this.littleEndian, 52, 8);\r\n        if (relative) this.offset += 8;\n        return value;\r\n    };\r\n\r\n    /**\r\n     * Reads a 64bit float. This is an alias of {@link ByteBuffer#readFloat64}.\r\n     * @function\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.\r\n     * @returns {number}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readDouble = ByteBufferPrototype.readFloat64;\r\n\r\n\r\n    // types/varints/varint32\r\n\r\n    /**\r\n     * Maximum number of bytes required to store a 32bit base 128 variable-length integer.\r\n     * @type {number}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.MAX_VARINT32_BYTES = 5;\r\n\r\n    /**\r\n     * Calculates the actual number of bytes required to store a 32bit base 128 variable-length integer.\r\n     * @param {number} value Value to encode\r\n     * @returns {number} Number of bytes required. Capped to {@link ByteBuffer.MAX_VARINT32_BYTES}\r\n     * @expose\r\n     */\r\n    ByteBuffer.calculateVarint32 = function(value) {\r\n        // ref: src/google/protobuf/io/coded_stream.cc\r\n        value = value >>> 0;\r\n             if (value < 1 << 7 ) return 1;\r\n        else if (value < 1 << 14) return 2;\r\n        else if (value < 1 << 21) return 3;\r\n        else if (value < 1 << 28) return 4;\r\n        else                      return 5;\r\n    };\r\n\r\n    /**\r\n     * Zigzag encodes a signed 32bit integer so that it can be effectively used with varint encoding.\r\n     * @param {number} n Signed 32bit integer\r\n     * @returns {number} Unsigned zigzag encoded 32bit integer\r\n     * @expose\r\n     */\r\n    ByteBuffer.zigZagEncode32 = function(n) {\r\n        return (((n |= 0) << 1) ^ (n >> 31)) >>> 0; // ref: src/google/protobuf/wire_format_lite.h\r\n    };\r\n\r\n    /**\r\n     * Decodes a zigzag encoded signed 32bit integer.\r\n     * @param {number} n Unsigned zigzag encoded 32bit integer\r\n     * @returns {number} Signed 32bit integer\r\n     * @expose\r\n     */\r\n    ByteBuffer.zigZagDecode32 = function(n) {\r\n        return ((n >>> 1) ^ -(n & 1)) | 0; // // ref: src/google/protobuf/wire_format_lite.h\r\n    };\r\n\r\n    /**\r\n     * Writes a 32bit base 128 variable-length integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer|number} this if `offset` is omitted, else the actual number of bytes written\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeVarint32 = function(value, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var size = ByteBuffer.calculateVarint32(value),\r\n            b;\r\n        offset += size;\n        var capacity10 = this.buffer.byteLength;\n        if (offset > capacity10)\n            this.resize((capacity10 *= 2) > offset ? capacity10 : offset);\n        offset -= size;\n        value >>>= 0;\r\n        while (value >= 0x80) {\r\n            b = (value & 0x7f) | 0x80;\r\n            this.view[offset++] = b;\r\n            value >>>= 7;\r\n        }\r\n        this.view[offset++] = value;\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return size;\r\n    };\r\n\r\n    /**\r\n     * Writes a zig-zag encoded (signed) 32bit base 128 variable-length integer.\r\n     * @param {number} value Value to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer|number} this if `offset` is omitted, else the actual number of bytes written\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeVarint32ZigZag = function(value, offset) {\r\n        return this.writeVarint32(ByteBuffer.zigZagEncode32(value), offset);\r\n    };\r\n\r\n    /**\r\n     * Reads a 32bit base 128 variable-length integer.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {number|!{value: number, length: number}} The value read if offset is omitted, else the value read\r\n     *  and the actual number of bytes read.\r\n     * @throws {Error} If it's not a valid varint. Has a property `truncated = true` if there is not enough data available\r\n     *  to fully decode the varint.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readVarint32 = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var c = 0,\r\n            value = 0 >>> 0,\r\n            b;\r\n        do {\r\n            if (!this.noAssert && offset > this.limit) {\r\n                var err = Error(\"Truncated\");\r\n                err['truncated'] = true;\r\n                throw err;\r\n            }\r\n            b = this.view[offset++];\r\n            if (c < 5)\r\n                value |= (b & 0x7f) << (7*c);\r\n            ++c;\r\n        } while ((b & 0x80) !== 0);\r\n        value |= 0;\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return value;\r\n        }\r\n        return {\r\n            \"value\": value,\r\n            \"length\": c\r\n        };\r\n    };\r\n\r\n    /**\r\n     * Reads a zig-zag encoded (signed) 32bit base 128 variable-length integer.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {number|!{value: number, length: number}} The value read if offset is omitted, else the value read\r\n     *  and the actual number of bytes read.\r\n     * @throws {Error} If it's not a valid varint\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readVarint32ZigZag = function(offset) {\r\n        var val = this.readVarint32(offset);\r\n        if (typeof val === 'object')\r\n            val[\"value\"] = ByteBuffer.zigZagDecode32(val[\"value\"]);\r\n        else\r\n            val = ByteBuffer.zigZagDecode32(val);\r\n        return val;\r\n    };\r\n\r\n    // types/varints/varint64\r\n\r\n    if (Long) {\r\n\r\n        /**\r\n         * Maximum number of bytes required to store a 64bit base 128 variable-length integer.\r\n         * @type {number}\r\n         * @const\r\n         * @expose\r\n         */\r\n        ByteBuffer.MAX_VARINT64_BYTES = 10;\r\n\r\n        /**\r\n         * Calculates the actual number of bytes required to store a 64bit base 128 variable-length integer.\r\n         * @param {number|!Long} value Value to encode\r\n         * @returns {number} Number of bytes required. Capped to {@link ByteBuffer.MAX_VARINT64_BYTES}\r\n         * @expose\r\n         */\r\n        ByteBuffer.calculateVarint64 = function(value) {\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value);\n            else if (typeof value === 'string')\n                value = Long.fromString(value);\n            // ref: src/google/protobuf/io/coded_stream.cc\r\n            var part0 = value.toInt() >>> 0,\r\n                part1 = value.shiftRightUnsigned(28).toInt() >>> 0,\r\n                part2 = value.shiftRightUnsigned(56).toInt() >>> 0;\r\n            if (part2 == 0) {\r\n                if (part1 == 0) {\r\n                    if (part0 < 1 << 14)\r\n                        return part0 < 1 << 7 ? 1 : 2;\r\n                    else\r\n                        return part0 < 1 << 21 ? 3 : 4;\r\n                } else {\r\n                    if (part1 < 1 << 14)\r\n                        return part1 < 1 << 7 ? 5 : 6;\r\n                    else\r\n                        return part1 < 1 << 21 ? 7 : 8;\r\n                }\r\n            } else\r\n                return part2 < 1 << 7 ? 9 : 10;\r\n        };\r\n\r\n        /**\r\n         * Zigzag encodes a signed 64bit integer so that it can be effectively used with varint encoding.\r\n         * @param {number|!Long} value Signed long\r\n         * @returns {!Long} Unsigned zigzag encoded long\r\n         * @expose\r\n         */\r\n        ByteBuffer.zigZagEncode64 = function(value) {\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value, false);\n            else if (typeof value === 'string')\n                value = Long.fromString(value, false);\n            else if (value.unsigned !== false) value = value.toSigned();\n            // ref: src/google/protobuf/wire_format_lite.h\r\n            return value.shiftLeft(1).xor(value.shiftRight(63)).toUnsigned();\r\n        };\r\n\r\n        /**\r\n         * Decodes a zigzag encoded signed 64bit integer.\r\n         * @param {!Long|number} value Unsigned zigzag encoded long or JavaScript number\r\n         * @returns {!Long} Signed long\r\n         * @expose\r\n         */\r\n        ByteBuffer.zigZagDecode64 = function(value) {\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value, false);\n            else if (typeof value === 'string')\n                value = Long.fromString(value, false);\n            else if (value.unsigned !== false) value = value.toSigned();\n            // ref: src/google/protobuf/wire_format_lite.h\r\n            return value.shiftRightUnsigned(1).xor(value.and(Long.ONE).toSigned().negate()).toSigned();\r\n        };\r\n\r\n        /**\r\n         * Writes a 64bit base 128 variable-length integer.\r\n         * @param {number|Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n         *  written if omitted.\r\n         * @returns {!ByteBuffer|number} `this` if offset is omitted, else the actual number of bytes written.\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeVarint64 = function(value, offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof value === 'number')\n                    value = Long.fromNumber(value);\n                else if (typeof value === 'string')\n                    value = Long.fromString(value);\n                else if (!(value && value instanceof Long))\n                    throw TypeError(\"Illegal value: \"+value+\" (not an integer or Long)\");\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n            }\r\n            if (typeof value === 'number')\n                value = Long.fromNumber(value, false);\n            else if (typeof value === 'string')\n                value = Long.fromString(value, false);\n            else if (value.unsigned !== false) value = value.toSigned();\n            var size = ByteBuffer.calculateVarint64(value),\r\n                part0 = value.toInt() >>> 0,\r\n                part1 = value.shiftRightUnsigned(28).toInt() >>> 0,\r\n                part2 = value.shiftRightUnsigned(56).toInt() >>> 0;\r\n            offset += size;\n            var capacity11 = this.buffer.byteLength;\n            if (offset > capacity11)\n                this.resize((capacity11 *= 2) > offset ? capacity11 : offset);\n            offset -= size;\n            switch (size) {\r\n                case 10: this.view[offset+9] = (part2 >>>  7) & 0x01;\r\n                case 9 : this.view[offset+8] = size !== 9 ? (part2       ) | 0x80 : (part2       ) & 0x7F;\r\n                case 8 : this.view[offset+7] = size !== 8 ? (part1 >>> 21) | 0x80 : (part1 >>> 21) & 0x7F;\r\n                case 7 : this.view[offset+6] = size !== 7 ? (part1 >>> 14) | 0x80 : (part1 >>> 14) & 0x7F;\r\n                case 6 : this.view[offset+5] = size !== 6 ? (part1 >>>  7) | 0x80 : (part1 >>>  7) & 0x7F;\r\n                case 5 : this.view[offset+4] = size !== 5 ? (part1       ) | 0x80 : (part1       ) & 0x7F;\r\n                case 4 : this.view[offset+3] = size !== 4 ? (part0 >>> 21) | 0x80 : (part0 >>> 21) & 0x7F;\r\n                case 3 : this.view[offset+2] = size !== 3 ? (part0 >>> 14) | 0x80 : (part0 >>> 14) & 0x7F;\r\n                case 2 : this.view[offset+1] = size !== 2 ? (part0 >>>  7) | 0x80 : (part0 >>>  7) & 0x7F;\r\n                case 1 : this.view[offset  ] = size !== 1 ? (part0       ) | 0x80 : (part0       ) & 0x7F;\r\n            }\r\n            if (relative) {\r\n                this.offset += size;\r\n                return this;\r\n            } else {\r\n                return size;\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Writes a zig-zag encoded 64bit base 128 variable-length integer.\r\n         * @param {number|Long} value Value to write\r\n         * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n         *  written if omitted.\r\n         * @returns {!ByteBuffer|number} `this` if offset is omitted, else the actual number of bytes written.\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.writeVarint64ZigZag = function(value, offset) {\r\n            return this.writeVarint64(ByteBuffer.zigZagEncode64(value), offset);\r\n        };\r\n\r\n        /**\r\n         * Reads a 64bit base 128 variable-length integer. Requires Long.js.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n         *  read if omitted.\r\n         * @returns {!Long|!{value: Long, length: number}} The value read if offset is omitted, else the value read and\r\n         *  the actual number of bytes read.\r\n         * @throws {Error} If it's not a valid varint\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readVarint64 = function(offset) {\r\n            var relative = typeof offset === 'undefined';\n            if (relative) offset = this.offset;\n            if (!this.noAssert) {\r\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n            }\r\n            // ref: src/google/protobuf/io/coded_stream.cc\r\n            var start = offset,\r\n                part0 = 0,\r\n                part1 = 0,\r\n                part2 = 0,\r\n                b  = 0;\r\n            b = this.view[offset++]; part0  = (b & 0x7F)      ; if ( b & 0x80                                                   ) {\r\n            b = this.view[offset++]; part0 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part0 |= (b & 0x7F) << 14; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part0 |= (b & 0x7F) << 21; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part1  = (b & 0x7F)      ; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part1 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part1 |= (b & 0x7F) << 14; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part1 |= (b & 0x7F) << 21; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part2  = (b & 0x7F)      ; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            b = this.view[offset++]; part2 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {\r\n            throw Error(\"Buffer overrun\"); }}}}}}}}}}\r\n            var value = Long.fromBits(part0 | (part1 << 28), (part1 >>> 4) | (part2) << 24, false);\r\n            if (relative) {\r\n                this.offset = offset;\r\n                return value;\r\n            } else {\r\n                return {\r\n                    'value': value,\r\n                    'length': offset-start\r\n                };\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Reads a zig-zag encoded 64bit base 128 variable-length integer. Requires Long.js.\r\n         * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n         *  read if omitted.\r\n         * @returns {!Long|!{value: Long, length: number}} The value read if offset is omitted, else the value read and\r\n         *  the actual number of bytes read.\r\n         * @throws {Error} If it's not a valid varint\r\n         * @expose\r\n         */\r\n        ByteBufferPrototype.readVarint64ZigZag = function(offset) {\r\n            var val = this.readVarint64(offset);\r\n            if (val && val['value'] instanceof Long)\r\n                val[\"value\"] = ByteBuffer.zigZagDecode64(val[\"value\"]);\r\n            else\r\n                val = ByteBuffer.zigZagDecode64(val);\r\n            return val;\r\n        };\r\n\r\n    } // Long\r\n\r\n\r\n    // types/strings/cstring\r\n\r\n    /**\r\n     * Writes a NULL-terminated UTF8 encoded string. For this to work the specified string must not contain any NULL\r\n     *  characters itself.\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  contained in `str` + 1 if omitted.\r\n     * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeCString = function(str, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        var i,\r\n            k = str.length;\r\n        if (!this.noAssert) {\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n            for (i=0; i<k; ++i) {\r\n                if (str.charCodeAt(i) === 0)\r\n                    throw RangeError(\"Illegal str: Contains NULL-characters\");\r\n            }\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        // UTF8 strings do not contain zero bytes in between except for the zero character, so:\r\n        k = utfx.calculateUTF16asUTF8(stringSource(str))[1];\r\n        offset += k+1;\n        var capacity12 = this.buffer.byteLength;\n        if (offset > capacity12)\n            this.resize((capacity12 *= 2) > offset ? capacity12 : offset);\n        offset -= k+1;\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            this.view[offset++] = b;\r\n        }.bind(this));\r\n        this.view[offset++] = 0;\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return k;\r\n    };\r\n\r\n    /**\r\n     * Reads a NULL-terminated UTF8 encoded string. For this to work the string read must not contain any NULL characters\r\n     *  itself.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readCString = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset,\r\n            temp;\r\n        // UTF8 strings do not contain zero bytes in between except for the zero character itself, so:\r\n        var sd, b = -1;\r\n        utfx.decodeUTF8toUTF16(function() {\r\n            if (b === 0) return null;\r\n            if (offset >= this.limit)\r\n                throw RangeError(\"Illegal range: Truncated data, \"+offset+\" < \"+this.limit);\r\n            b = this.view[offset++];\r\n            return b === 0 ? null : b;\r\n        }.bind(this), sd = stringDestination(), true);\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return sd();\r\n        } else {\r\n            return {\r\n                \"string\": sd(),\r\n                \"length\": offset - start\r\n            };\r\n        }\r\n    };\r\n\r\n    // types/strings/istring\r\n\r\n    /**\r\n     * Writes a length as uint32 prefixed UTF8 encoded string.\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer|number} `this` if `offset` is omitted, else the actual number of bytes written\r\n     * @expose\r\n     * @see ByteBuffer#writeVarint32\r\n     */\r\n    ByteBufferPrototype.writeIString = function(str, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset,\r\n            k;\r\n        k = utfx.calculateUTF16asUTF8(stringSource(str), this.noAssert)[1];\r\n        offset += 4+k;\n        var capacity13 = this.buffer.byteLength;\n        if (offset > capacity13)\n            this.resize((capacity13 *= 2) > offset ? capacity13 : offset);\n        offset -= 4+k;\n        if (this.littleEndian) {\n            this.view[offset+3] = (k >>> 24) & 0xFF;\n            this.view[offset+2] = (k >>> 16) & 0xFF;\n            this.view[offset+1] = (k >>>  8) & 0xFF;\n            this.view[offset  ] =  k         & 0xFF;\n        } else {\n            this.view[offset  ] = (k >>> 24) & 0xFF;\n            this.view[offset+1] = (k >>> 16) & 0xFF;\n            this.view[offset+2] = (k >>>  8) & 0xFF;\n            this.view[offset+3] =  k         & 0xFF;\n        }\n        offset += 4;\r\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            this.view[offset++] = b;\r\n        }.bind(this));\r\n        if (offset !== start + 4 + k)\r\n            throw RangeError(\"Illegal range: Truncated data, \"+offset+\" == \"+(offset+4+k));\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return offset - start;\r\n    };\r\n\r\n    /**\r\n     * Reads a length as uint32 prefixed UTF8 encoded string.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     * @see ByteBuffer#readVarint32\r\n     */\r\n    ByteBufferPrototype.readIString = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 4 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+4+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset;\r\n        var len = this.readUint32(offset);\r\n        var str = this.readUTF8String(len, ByteBuffer.METRICS_BYTES, offset += 4);\r\n        offset += str['length'];\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return str['string'];\r\n        } else {\r\n            return {\r\n                'string': str['string'],\r\n                'length': offset - start\r\n            };\r\n        }\r\n    };\r\n\r\n    // types/strings/utf8string\r\n\r\n    /**\r\n     * Metrics representing number of UTF8 characters. Evaluates to `c`.\r\n     * @type {string}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.METRICS_CHARS = 'c';\r\n\r\n    /**\r\n     * Metrics representing number of bytes. Evaluates to `b`.\r\n     * @type {string}\r\n     * @const\r\n     * @expose\r\n     */\r\n    ByteBuffer.METRICS_BYTES = 'b';\r\n\r\n    /**\r\n     * Writes an UTF8 encoded string.\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} if omitted.\r\n     * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeUTF8String = function(str, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var k;\r\n        var start = offset;\r\n        k = utfx.calculateUTF16asUTF8(stringSource(str))[1];\r\n        offset += k;\n        var capacity14 = this.buffer.byteLength;\n        if (offset > capacity14)\n            this.resize((capacity14 *= 2) > offset ? capacity14 : offset);\n        offset -= k;\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            this.view[offset++] = b;\r\n        }.bind(this));\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return offset - start;\r\n    };\r\n\r\n    /**\r\n     * Writes an UTF8 encoded string. This is an alias of {@link ByteBuffer#writeUTF8String}.\r\n     * @function\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} if omitted.\r\n     * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.writeString = ByteBufferPrototype.writeUTF8String;\r\n\r\n    /**\r\n     * Calculates the number of UTF8 characters of a string. JavaScript itself uses UTF-16, so that a string's\r\n     *  `length` property does not reflect its actual UTF8 size if it contains code points larger than 0xFFFF.\r\n     * @param {string} str String to calculate\r\n     * @returns {number} Number of UTF8 characters\r\n     * @expose\r\n     */\r\n    ByteBuffer.calculateUTF8Chars = function(str) {\r\n        return utfx.calculateUTF16asUTF8(stringSource(str))[0];\r\n    };\r\n\r\n    /**\r\n     * Calculates the number of UTF8 bytes of a string.\r\n     * @param {string} str String to calculate\r\n     * @returns {number} Number of UTF8 bytes\r\n     * @expose\r\n     */\r\n    ByteBuffer.calculateUTF8Bytes = function(str) {\r\n        return utfx.calculateUTF16asUTF8(stringSource(str))[1];\r\n    };\r\n\r\n    /**\r\n     * Calculates the number of UTF8 bytes of a string. This is an alias of {@link ByteBuffer.calculateUTF8Bytes}.\r\n     * @function\r\n     * @param {string} str String to calculate\r\n     * @returns {number} Number of UTF8 bytes\r\n     * @expose\r\n     */\r\n    ByteBuffer.calculateString = ByteBuffer.calculateUTF8Bytes;\r\n\r\n    /**\r\n     * Reads an UTF8 encoded string.\r\n     * @param {number} length Number of characters or bytes to read.\r\n     * @param {string=} metrics Metrics specifying what `length` is meant to count. Defaults to\r\n     *  {@link ByteBuffer.METRICS_CHARS}.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readUTF8String = function(length, metrics, offset) {\r\n        if (typeof metrics === 'number') {\r\n            offset = metrics;\r\n            metrics = undefined;\r\n        }\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (typeof metrics === 'undefined') metrics = ByteBuffer.METRICS_CHARS;\r\n        if (!this.noAssert) {\r\n            if (typeof length !== 'number' || length % 1 !== 0)\n                throw TypeError(\"Illegal length: \"+length+\" (not an integer)\");\n            length |= 0;\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var i = 0,\r\n            start = offset,\r\n            sd;\r\n        if (metrics === ByteBuffer.METRICS_CHARS) { // The same for node and the browser\r\n            sd = stringDestination();\r\n            utfx.decodeUTF8(function() {\r\n                return i < length && offset < this.limit ? this.view[offset++] : null;\r\n            }.bind(this), function(cp) {\r\n                ++i; utfx.UTF8toUTF16(cp, sd);\r\n            });\r\n            if (i !== length)\r\n                throw RangeError(\"Illegal range: Truncated data, \"+i+\" == \"+length);\r\n            if (relative) {\r\n                this.offset = offset;\r\n                return sd();\r\n            } else {\r\n                return {\r\n                    \"string\": sd(),\r\n                    \"length\": offset - start\r\n                };\r\n            }\r\n        } else if (metrics === ByteBuffer.METRICS_BYTES) {\r\n            if (!this.noAssert) {\r\n                if (typeof offset !== 'number' || offset % 1 !== 0)\n                    throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n                offset >>>= 0;\n                if (offset < 0 || offset + length > this.buffer.byteLength)\n                    throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+length+\") <= \"+this.buffer.byteLength);\n            }\r\n            var k = offset + length;\r\n            utfx.decodeUTF8toUTF16(function() {\r\n                return offset < k ? this.view[offset++] : null;\r\n            }.bind(this), sd = stringDestination(), this.noAssert);\r\n            if (offset !== k)\r\n                throw RangeError(\"Illegal range: Truncated data, \"+offset+\" == \"+k);\r\n            if (relative) {\r\n                this.offset = offset;\r\n                return sd();\r\n            } else {\r\n                return {\r\n                    'string': sd(),\r\n                    'length': offset - start\r\n                };\r\n            }\r\n        } else\r\n            throw TypeError(\"Unsupported metrics: \"+metrics);\r\n    };\r\n\r\n    /**\r\n     * Reads an UTF8 encoded string. This is an alias of {@link ByteBuffer#readUTF8String}.\r\n     * @function\r\n     * @param {number} length Number of characters or bytes to read\r\n     * @param {number=} metrics Metrics specifying what `n` is meant to count. Defaults to\r\n     *  {@link ByteBuffer.METRICS_CHARS}.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.readString = ByteBufferPrototype.readUTF8String;\r\n\r\n    // types/strings/vstring\r\n\r\n    /**\r\n     * Writes a length as varint32 prefixed UTF8 encoded string.\r\n     * @param {string} str String to write\r\n     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer|number} `this` if `offset` is omitted, else the actual number of bytes written\r\n     * @expose\r\n     * @see ByteBuffer#writeVarint32\r\n     */\r\n    ByteBufferPrototype.writeVString = function(str, offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset,\r\n            k, l;\r\n        k = utfx.calculateUTF16asUTF8(stringSource(str), this.noAssert)[1];\r\n        l = ByteBuffer.calculateVarint32(k);\r\n        offset += l+k;\n        var capacity15 = this.buffer.byteLength;\n        if (offset > capacity15)\n            this.resize((capacity15 *= 2) > offset ? capacity15 : offset);\n        offset -= l+k;\n        offset += this.writeVarint32(k, offset);\r\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            this.view[offset++] = b;\r\n        }.bind(this));\r\n        if (offset !== start+k+l)\r\n            throw RangeError(\"Illegal range: Truncated data, \"+offset+\" == \"+(offset+k+l));\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return this;\r\n        }\r\n        return offset - start;\r\n    };\r\n\r\n    /**\r\n     * Reads a length as varint32 prefixed UTF8 encoded string.\r\n     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string\r\n     *  read and the actual number of bytes read.\r\n     * @expose\r\n     * @see ByteBuffer#readVarint32\r\n     */\r\n    ByteBufferPrototype.readVString = function(offset) {\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 1 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+1+\") <= \"+this.buffer.byteLength);\n        }\r\n        var start = offset;\r\n        var len = this.readVarint32(offset);\r\n        var str = this.readUTF8String(len['value'], ByteBuffer.METRICS_BYTES, offset += len['length']);\r\n        offset += str['length'];\r\n        if (relative) {\r\n            this.offset = offset;\r\n            return str['string'];\r\n        } else {\r\n            return {\r\n                'string': str['string'],\r\n                'length': offset - start\r\n            };\r\n        }\r\n    };\r\n\r\n\r\n    /**\r\n     * Appends some data to this ByteBuffer. This will overwrite any contents behind the specified offset up to the appended\r\n     *  data's length.\r\n     * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string} source Data to append. If `source` is a ByteBuffer, its offsets\r\n     *  will be modified according to the performed read operation.\r\n     * @param {(string|number)=} encoding Encoding if `data` is a string (\"base64\", \"hex\", \"binary\", defaults to \"utf8\")\r\n     * @param {number=} offset Offset to append at. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @example A relative `<01 02>03.append(<04 05>)` will result in `<01 02 04 05>, 04 05|`\r\n     * @example An absolute `<01 02>03.append(04 05>, 1)` will result in `<01 04>05, 04 05|`\r\n     */\r\n    ByteBufferPrototype.append = function(source, encoding, offset) {\r\n        if (typeof encoding === 'number' || typeof encoding !== 'string') {\r\n            offset = encoding;\r\n            encoding = undefined;\r\n        }\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        if (!(source instanceof ByteBuffer))\r\n            source = ByteBuffer.wrap(source, encoding);\r\n        var length = source.limit - source.offset;\r\n        if (length <= 0) return this; // Nothing to append\r\n        offset += length;\n        var capacity16 = this.buffer.byteLength;\n        if (offset > capacity16)\n            this.resize((capacity16 *= 2) > offset ? capacity16 : offset);\n        offset -= length;\n        this.view.set(source.view.subarray(source.offset, source.limit), offset);\r\n        source.offset += length;\r\n        if (relative) this.offset += length;\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Appends this ByteBuffer's contents to another ByteBuffer. This will overwrite any contents at and after the\r\n        specified offset up to the length of this ByteBuffer's data.\r\n     * @param {!ByteBuffer} target Target ByteBuffer\r\n     * @param {number=} offset Offset to append to. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  read if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @see ByteBuffer#append\r\n     */\r\n    ByteBufferPrototype.appendTo = function(target, offset) {\r\n        target.append(this, offset);\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Enables or disables assertions of argument types and offsets. Assertions are enabled by default but you can opt to\r\n     *  disable them if your code already makes sure that everything is valid.\r\n     * @param {boolean} assert `true` to enable assertions, otherwise `false`\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.assert = function(assert) {\r\n        this.noAssert = !assert;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Gets the capacity of this ByteBuffer's backing buffer.\r\n     * @returns {number} Capacity of the backing buffer\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.capacity = function() {\r\n        return this.buffer.byteLength;\r\n    };\r\n    /**\r\n     * Clears this ByteBuffer's offsets by setting {@link ByteBuffer#offset} to `0` and {@link ByteBuffer#limit} to the\r\n     *  backing buffer's capacity. Discards {@link ByteBuffer#markedOffset}.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.clear = function() {\r\n        this.offset = 0;\r\n        this.limit = this.buffer.byteLength;\r\n        this.markedOffset = -1;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Creates a cloned instance of this ByteBuffer, preset with this ByteBuffer's values for {@link ByteBuffer#offset},\r\n     *  {@link ByteBuffer#markedOffset} and {@link ByteBuffer#limit}.\r\n     * @param {boolean=} copy Whether to copy the backing buffer or to return another view on the same, defaults to `false`\r\n     * @returns {!ByteBuffer} Cloned instance\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.clone = function(copy) {\r\n        var bb = new ByteBuffer(0, this.littleEndian, this.noAssert);\r\n        if (copy) {\r\n            bb.buffer = new ArrayBuffer(this.buffer.byteLength);\r\n            bb.view = new Uint8Array(bb.buffer);\r\n        } else {\r\n            bb.buffer = this.buffer;\r\n            bb.view = this.view;\r\n        }\r\n        bb.offset = this.offset;\r\n        bb.markedOffset = this.markedOffset;\r\n        bb.limit = this.limit;\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Compacts this ByteBuffer to be backed by a {@link ByteBuffer#buffer} of its contents' length. Contents are the bytes\r\n     *  between {@link ByteBuffer#offset} and {@link ByteBuffer#limit}. Will set `offset = 0` and `limit = capacity` and\r\n     *  adapt {@link ByteBuffer#markedOffset} to the same relative position if set.\r\n     * @param {number=} begin Offset to start at, defaults to {@link ByteBuffer#offset}\r\n     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.compact = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        if (begin === 0 && end === this.buffer.byteLength)\r\n            return this; // Already compacted\r\n        var len = end - begin;\r\n        if (len === 0) {\r\n            this.buffer = EMPTY_BUFFER;\r\n            this.view = null;\r\n            if (this.markedOffset >= 0) this.markedOffset -= begin;\r\n            this.offset = 0;\r\n            this.limit = 0;\r\n            return this;\r\n        }\r\n        var buffer = new ArrayBuffer(len);\r\n        var view = new Uint8Array(buffer);\r\n        view.set(this.view.subarray(begin, end));\r\n        this.buffer = buffer;\r\n        this.view = view;\r\n        if (this.markedOffset >= 0) this.markedOffset -= begin;\r\n        this.offset = 0;\r\n        this.limit = len;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Creates a copy of this ByteBuffer's contents. Contents are the bytes between {@link ByteBuffer#offset} and\r\n     *  {@link ByteBuffer#limit}.\r\n     * @param {number=} begin Begin offset, defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.\r\n     * @returns {!ByteBuffer} Copy\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.copy = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        if (begin === end)\r\n            return new ByteBuffer(0, this.littleEndian, this.noAssert);\r\n        var capacity = end - begin,\r\n            bb = new ByteBuffer(capacity, this.littleEndian, this.noAssert);\r\n        bb.offset = 0;\r\n        bb.limit = capacity;\r\n        if (bb.markedOffset >= 0) bb.markedOffset -= begin;\r\n        this.copyTo(bb, 0, begin, end);\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Copies this ByteBuffer's contents to another ByteBuffer. Contents are the bytes between {@link ByteBuffer#offset} and\r\n     *  {@link ByteBuffer#limit}.\r\n     * @param {!ByteBuffer} target Target ByteBuffer\r\n     * @param {number=} targetOffset Offset to copy to. Will use and increase the target's {@link ByteBuffer#offset}\r\n     *  by the number of bytes copied if omitted.\r\n     * @param {number=} sourceOffset Offset to start copying from. Will use and increase {@link ByteBuffer#offset} by the\r\n     *  number of bytes copied if omitted.\r\n     * @param {number=} sourceLimit Offset to end copying from, defaults to {@link ByteBuffer#limit}\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.copyTo = function(target, targetOffset, sourceOffset, sourceLimit) {\r\n        var relative,\r\n            targetRelative;\r\n        if (!this.noAssert) {\r\n            if (!ByteBuffer.isByteBuffer(target))\r\n                throw TypeError(\"Illegal target: Not a ByteBuffer\");\r\n        }\r\n        targetOffset = (targetRelative = typeof targetOffset === 'undefined') ? target.offset : targetOffset | 0;\r\n        sourceOffset = (relative = typeof sourceOffset === 'undefined') ? this.offset : sourceOffset | 0;\r\n        sourceLimit = typeof sourceLimit === 'undefined' ? this.limit : sourceLimit | 0;\r\n\r\n        if (targetOffset < 0 || targetOffset > target.buffer.byteLength)\r\n            throw RangeError(\"Illegal target range: 0 <= \"+targetOffset+\" <= \"+target.buffer.byteLength);\r\n        if (sourceOffset < 0 || sourceLimit > this.buffer.byteLength)\r\n            throw RangeError(\"Illegal source range: 0 <= \"+sourceOffset+\" <= \"+this.buffer.byteLength);\r\n\r\n        var len = sourceLimit - sourceOffset;\r\n        if (len === 0)\r\n            return target; // Nothing to copy\r\n\r\n        target.ensureCapacity(targetOffset + len);\r\n\r\n        target.view.set(this.view.subarray(sourceOffset, sourceLimit), targetOffset);\r\n\r\n        if (relative) this.offset += len;\r\n        if (targetRelative) target.offset += len;\r\n\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Makes sure that this ByteBuffer is backed by a {@link ByteBuffer#buffer} of at least the specified capacity. If the\r\n     *  current capacity is exceeded, it will be doubled. If double the current capacity is less than the required capacity,\r\n     *  the required capacity will be used instead.\r\n     * @param {number} capacity Required capacity\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.ensureCapacity = function(capacity) {\r\n        var current = this.buffer.byteLength;\r\n        if (current < capacity)\r\n            return this.resize((current *= 2) > capacity ? current : capacity);\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Overwrites this ByteBuffer's contents with the specified value. Contents are the bytes between\r\n     *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}.\r\n     * @param {number|string} value Byte value to fill with. If given as a string, the first character is used.\r\n     * @param {number=} begin Begin offset. Will use and increase {@link ByteBuffer#offset} by the number of bytes\r\n     *  written if omitted. defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @example `someByteBuffer.clear().fill(0)` fills the entire backing buffer with zeroes\r\n     */\r\n    ByteBufferPrototype.fill = function(value, begin, end) {\r\n        var relative = typeof begin === 'undefined';\n        if (relative) begin = this.offset;\n        if (typeof value === 'string' && value.length > 0)\r\n            value = value.charCodeAt(0);\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof value !== 'number' || value % 1 !== 0)\n                throw TypeError(\"Illegal value: \"+value+\" (not an integer)\");\n            value |= 0;\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        if (begin >= end)\r\n            return this; // Nothing to fill\r\n        while (begin < end) this.view[begin++] = value;\r\n        if (relative) this.offset = begin;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Makes this ByteBuffer ready for a new sequence of write or relative read operations. Sets `limit = offset` and\r\n     *  `offset = 0`. Make sure always to flip a ByteBuffer when all relative read or write operations are complete.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.flip = function() {\r\n        this.limit = this.offset;\r\n        this.offset = 0;\r\n        return this;\r\n    };\r\n    /**\r\n     * Marks an offset on this ByteBuffer to be used later.\r\n     * @param {number=} offset Offset to mark. Defaults to {@link ByteBuffer#offset}.\r\n     * @returns {!ByteBuffer} this\r\n     * @throws {TypeError} If `offset` is not a valid number\r\n     * @throws {RangeError} If `offset` is out of bounds\r\n     * @see ByteBuffer#reset\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.mark = function(offset) {\r\n        offset = typeof offset === 'undefined' ? this.offset : offset;\r\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        this.markedOffset = offset;\r\n        return this;\r\n    };\r\n    /**\r\n     * Sets the byte order.\r\n     * @param {boolean} littleEndian `true` for little endian byte order, `false` for big endian\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.order = function(littleEndian) {\r\n        if (!this.noAssert) {\r\n            if (typeof littleEndian !== 'boolean')\r\n                throw TypeError(\"Illegal littleEndian: Not a boolean\");\r\n        }\r\n        this.littleEndian = !!littleEndian;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Switches (to) little endian byte order.\r\n     * @param {boolean=} littleEndian Defaults to `true`, otherwise uses big endian\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.LE = function(littleEndian) {\r\n        this.littleEndian = typeof littleEndian !== 'undefined' ? !!littleEndian : true;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Switches (to) big endian byte order.\r\n     * @param {boolean=} bigEndian Defaults to `true`, otherwise uses little endian\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.BE = function(bigEndian) {\r\n        this.littleEndian = typeof bigEndian !== 'undefined' ? !bigEndian : false;\r\n        return this;\r\n    };\r\n    /**\r\n     * Prepends some data to this ByteBuffer. This will overwrite any contents before the specified offset up to the\r\n     *  prepended data's length. If there is not enough space available before the specified `offset`, the backing buffer\r\n     *  will be resized and its contents moved accordingly.\r\n     * @param {!ByteBuffer|string|!ArrayBuffer} source Data to prepend. If `source` is a ByteBuffer, its offset will be\r\n     *  modified according to the performed read operation.\r\n     * @param {(string|number)=} encoding Encoding if `data` is a string (\"base64\", \"hex\", \"binary\", defaults to \"utf8\")\r\n     * @param {number=} offset Offset to prepend at. Will use and decrease {@link ByteBuffer#offset} by the number of bytes\r\n     *  prepended if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @example A relative `00<01 02 03>.prepend(<04 05>)` results in `<04 05 01 02 03>, 04 05|`\r\n     * @example An absolute `00<01 02 03>.prepend(<04 05>, 2)` results in `04<05 02 03>, 04 05|`\r\n     */\r\n    ByteBufferPrototype.prepend = function(source, encoding, offset) {\r\n        if (typeof encoding === 'number' || typeof encoding !== 'string') {\r\n            offset = encoding;\r\n            encoding = undefined;\r\n        }\r\n        var relative = typeof offset === 'undefined';\n        if (relative) offset = this.offset;\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: \"+offset+\" (not an integer)\");\n            offset >>>= 0;\n            if (offset < 0 || offset + 0 > this.buffer.byteLength)\n                throw RangeError(\"Illegal offset: 0 <= \"+offset+\" (+\"+0+\") <= \"+this.buffer.byteLength);\n        }\r\n        if (!(source instanceof ByteBuffer))\r\n            source = ByteBuffer.wrap(source, encoding);\r\n        var len = source.limit - source.offset;\r\n        if (len <= 0) return this; // Nothing to prepend\r\n        var diff = len - offset;\r\n        if (diff > 0) { // Not enough space before offset, so resize + move\r\n            var buffer = new ArrayBuffer(this.buffer.byteLength + diff);\r\n            var view = new Uint8Array(buffer);\r\n            view.set(this.view.subarray(offset, this.buffer.byteLength), len);\r\n            this.buffer = buffer;\r\n            this.view = view;\r\n            this.offset += diff;\r\n            if (this.markedOffset >= 0) this.markedOffset += diff;\r\n            this.limit += diff;\r\n            offset += diff;\r\n        } else {\r\n            var arrayView = new Uint8Array(this.buffer);\r\n        }\r\n        this.view.set(source.view.subarray(source.offset, source.limit), offset - len);\r\n\r\n        source.offset = source.limit;\r\n        if (relative)\r\n            this.offset -= len;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Prepends this ByteBuffer to another ByteBuffer. This will overwrite any contents before the specified offset up to the\r\n     *  prepended data's length. If there is not enough space available before the specified `offset`, the backing buffer\r\n     *  will be resized and its contents moved accordingly.\r\n     * @param {!ByteBuffer} target Target ByteBuffer\r\n     * @param {number=} offset Offset to prepend at. Will use and decrease {@link ByteBuffer#offset} by the number of bytes\r\n     *  prepended if omitted.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     * @see ByteBuffer#prepend\r\n     */\r\n    ByteBufferPrototype.prependTo = function(target, offset) {\r\n        target.prepend(this, offset);\r\n        return this;\r\n    };\r\n    /**\r\n     * Prints debug information about this ByteBuffer's contents.\r\n     * @param {function(string)=} out Output function to call, defaults to console.log\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.printDebug = function(out) {\r\n        if (typeof out !== 'function') out = console.log.bind(console);\r\n        out(\r\n            this.toString()+\"\\n\"+\r\n            \"-------------------------------------------------------------------\\n\"+\r\n            this.toDebug(/* columns */ true)\r\n        );\r\n    };\r\n\r\n    /**\r\n     * Gets the number of remaining readable bytes. Contents are the bytes between {@link ByteBuffer#offset} and\r\n     *  {@link ByteBuffer#limit}, so this returns `limit - offset`.\r\n     * @returns {number} Remaining readable bytes. May be negative if `offset > limit`.\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.remaining = function() {\r\n        return this.limit - this.offset;\r\n    };\r\n    /**\r\n     * Resets this ByteBuffer's {@link ByteBuffer#offset}. If an offset has been marked through {@link ByteBuffer#mark}\r\n     *  before, `offset` will be set to {@link ByteBuffer#markedOffset}, which will then be discarded. If no offset has been\r\n     *  marked, sets `offset = 0`.\r\n     * @returns {!ByteBuffer} this\r\n     * @see ByteBuffer#mark\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.reset = function() {\r\n        if (this.markedOffset >= 0) {\r\n            this.offset = this.markedOffset;\r\n            this.markedOffset = -1;\r\n        } else {\r\n            this.offset = 0;\r\n        }\r\n        return this;\r\n    };\r\n    /**\r\n     * Resizes this ByteBuffer to be backed by a buffer of at least the given capacity. Will do nothing if already that\r\n     *  large or larger.\r\n     * @param {number} capacity Capacity required\r\n     * @returns {!ByteBuffer} this\r\n     * @throws {TypeError} If `capacity` is not a number\r\n     * @throws {RangeError} If `capacity < 0`\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.resize = function(capacity) {\r\n        if (!this.noAssert) {\r\n            if (typeof capacity !== 'number' || capacity % 1 !== 0)\n                throw TypeError(\"Illegal capacity: \"+capacity+\" (not an integer)\");\n            capacity |= 0;\n            if (capacity < 0)\r\n                throw RangeError(\"Illegal capacity: 0 <= \"+capacity);\r\n        }\r\n        if (this.buffer.byteLength < capacity) {\r\n            var buffer = new ArrayBuffer(capacity);\r\n            var view = new Uint8Array(buffer);\r\n            view.set(this.view);\r\n            this.buffer = buffer;\r\n            this.view = view;\r\n        }\r\n        return this;\r\n    };\r\n    /**\r\n     * Reverses this ByteBuffer's contents.\r\n     * @param {number=} begin Offset to start at, defaults to {@link ByteBuffer#offset}\r\n     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.reverse = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        if (begin === end)\r\n            return this; // Nothing to reverse\r\n        Array.prototype.reverse.call(this.view.subarray(begin, end));\r\n        return this;\r\n    };\r\n    /**\r\n     * Skips the next `length` bytes. This will just advance\r\n     * @param {number} length Number of bytes to skip. May also be negative to move the offset back.\r\n     * @returns {!ByteBuffer} this\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.skip = function(length) {\r\n        if (!this.noAssert) {\r\n            if (typeof length !== 'number' || length % 1 !== 0)\n                throw TypeError(\"Illegal length: \"+length+\" (not an integer)\");\n            length |= 0;\n        }\r\n        var offset = this.offset + length;\r\n        if (!this.noAssert) {\r\n            if (offset < 0 || offset > this.buffer.byteLength)\r\n                throw RangeError(\"Illegal length: 0 <= \"+this.offset+\" + \"+length+\" <= \"+this.buffer.byteLength);\r\n        }\r\n        this.offset = offset;\r\n        return this;\r\n    };\r\n\r\n    /**\r\n     * Slices this ByteBuffer by creating a cloned instance with `offset = begin` and `limit = end`.\r\n     * @param {number=} begin Begin offset, defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.\r\n     * @returns {!ByteBuffer} Clone of this ByteBuffer with slicing applied, backed by the same {@link ByteBuffer#buffer}\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.slice = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        var bb = this.clone();\r\n        bb.offset = begin;\r\n        bb.limit = end;\r\n        return bb;\r\n    };\r\n    /**\r\n     * Returns a copy of the backing buffer that contains this ByteBuffer's contents. Contents are the bytes between\r\n     *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}.\r\n     * @param {boolean=} forceCopy If `true` returns a copy, otherwise returns a view referencing the same memory if\r\n     *  possible. Defaults to `false`\r\n     * @returns {!ArrayBuffer} Contents as an ArrayBuffer\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toBuffer = function(forceCopy) {\r\n        var offset = this.offset,\r\n            limit = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof offset !== 'number' || offset % 1 !== 0)\n                throw TypeError(\"Illegal offset: Not an integer\");\n            offset >>>= 0;\n            if (typeof limit !== 'number' || limit % 1 !== 0)\n                throw TypeError(\"Illegal limit: Not an integer\");\n            limit >>>= 0;\n            if (offset < 0 || offset > limit || limit > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+offset+\" <= \"+limit+\" <= \"+this.buffer.byteLength);\n        }\r\n        // NOTE: It's not possible to have another ArrayBuffer reference the same memory as the backing buffer. This is\r\n        // possible with Uint8Array#subarray only, but we have to return an ArrayBuffer by contract. So:\r\n        if (!forceCopy && offset === 0 && limit === this.buffer.byteLength)\r\n            return this.buffer;\r\n        if (offset === limit)\r\n            return EMPTY_BUFFER;\r\n        var buffer = new ArrayBuffer(limit - offset);\r\n        new Uint8Array(buffer).set(new Uint8Array(this.buffer).subarray(offset, limit), 0);\r\n        return buffer;\r\n    };\r\n\r\n    /**\r\n     * Returns a raw buffer compacted to contain this ByteBuffer's contents. Contents are the bytes between\r\n     *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}. This is an alias of {@link ByteBuffer#toBuffer}.\r\n     * @function\r\n     * @param {boolean=} forceCopy If `true` returns a copy, otherwise returns a view referencing the same memory.\r\n     *  Defaults to `false`\r\n     * @returns {!ArrayBuffer} Contents as an ArrayBuffer\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toArrayBuffer = ByteBufferPrototype.toBuffer;\r\n\r\n    /**\r\n     * Converts the ByteBuffer's contents to a string.\r\n     * @param {string=} encoding Output encoding. Returns an informative string representation if omitted but also allows\r\n     *  direct conversion to \"utf8\", \"hex\", \"base64\" and \"binary\" encoding. \"debug\" returns a hex representation with\r\n     *  highlighted offsets.\r\n     * @param {number=} begin Offset to begin at, defaults to {@link ByteBuffer#offset}\r\n     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}\r\n     * @returns {string} String representation\r\n     * @throws {Error} If `encoding` is invalid\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toString = function(encoding, begin, end) {\r\n        if (typeof encoding === 'undefined')\r\n            return \"ByteBufferAB(offset=\"+this.offset+\",markedOffset=\"+this.markedOffset+\",limit=\"+this.limit+\",capacity=\"+this.capacity()+\")\";\r\n        if (typeof encoding === 'number')\r\n            encoding = \"utf8\",\r\n            begin = encoding,\r\n            end = begin;\r\n        switch (encoding) {\r\n            case \"utf8\":\r\n                return this.toUTF8(begin, end);\r\n            case \"base64\":\r\n                return this.toBase64(begin, end);\r\n            case \"hex\":\r\n                return this.toHex(begin, end);\r\n            case \"binary\":\r\n                return this.toBinary(begin, end);\r\n            case \"debug\":\r\n                return this.toDebug();\r\n            case \"columns\":\r\n                return this.toColumns();\r\n            default:\r\n                throw Error(\"Unsupported encoding: \"+encoding);\r\n        }\r\n    };\r\n\r\n    // lxiv-embeddable\r\n\r\n    /**\r\n     * lxiv-embeddable (c) 2014 Daniel Wirtz <dcode@dcode.io>\r\n     * Released under the Apache License, Version 2.0\r\n     * see: https://github.com/dcodeIO/lxiv for details\r\n     */\r\n    var lxiv = function() {\r\n        \"use strict\";\r\n\r\n        /**\r\n         * lxiv namespace.\r\n         * @type {!Object.<string,*>}\r\n         * @exports lxiv\r\n         */\r\n        var lxiv = {};\r\n\r\n        /**\r\n         * Character codes for output.\r\n         * @type {!Array.<number>}\r\n         * @inner\r\n         */\r\n        var aout = [\r\n            65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,\r\n            81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102,\r\n            103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118,\r\n            119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47\r\n        ];\r\n\r\n        /**\r\n         * Character codes for input.\r\n         * @type {!Array.<number>}\r\n         * @inner\r\n         */\r\n        var ain = [];\r\n        for (var i=0, k=aout.length; i<k; ++i)\r\n            ain[aout[i]] = i;\r\n\r\n        /**\r\n         * Encodes bytes to base64 char codes.\r\n         * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if\r\n         *  there are no more bytes left.\r\n         * @param {!function(number)} dst Characters destination as a function successively called with each encoded char\r\n         *  code.\r\n         */\r\n        lxiv.encode = function(src, dst) {\r\n            var b, t;\r\n            while ((b = src()) !== null) {\r\n                dst(aout[(b>>2)&0x3f]);\r\n                t = (b&0x3)<<4;\r\n                if ((b = src()) !== null) {\r\n                    t |= (b>>4)&0xf;\r\n                    dst(aout[(t|((b>>4)&0xf))&0x3f]);\r\n                    t = (b&0xf)<<2;\r\n                    if ((b = src()) !== null)\r\n                        dst(aout[(t|((b>>6)&0x3))&0x3f]),\r\n                        dst(aout[b&0x3f]);\r\n                    else\r\n                        dst(aout[t&0x3f]),\r\n                        dst(61);\r\n                } else\r\n                    dst(aout[t&0x3f]),\r\n                    dst(61),\r\n                    dst(61);\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Decodes base64 char codes to bytes.\r\n         * @param {!function():number|null} src Characters source as a function returning the next char code respectively\r\n         *  `null` if there are no more characters left.\r\n         * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.\r\n         * @throws {Error} If a character code is invalid\r\n         */\r\n        lxiv.decode = function(src, dst) {\r\n            var c, t1, t2;\r\n            function fail(c) {\r\n                throw Error(\"Illegal character code: \"+c);\r\n            }\r\n            while ((c = src()) !== null) {\r\n                t1 = ain[c];\r\n                if (typeof t1 === 'undefined') fail(c);\r\n                if ((c = src()) !== null) {\r\n                    t2 = ain[c];\r\n                    if (typeof t2 === 'undefined') fail(c);\r\n                    dst((t1<<2)>>>0|(t2&0x30)>>4);\r\n                    if ((c = src()) !== null) {\r\n                        t1 = ain[c];\r\n                        if (typeof t1 === 'undefined')\r\n                            if (c === 61) break; else fail(c);\r\n                        dst(((t2&0xf)<<4)>>>0|(t1&0x3c)>>2);\r\n                        if ((c = src()) !== null) {\r\n                            t2 = ain[c];\r\n                            if (typeof t2 === 'undefined')\r\n                                if (c === 61) break; else fail(c);\r\n                            dst(((t1&0x3)<<6)>>>0|t2);\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Tests if a string is valid base64.\r\n         * @param {string} str String to test\r\n         * @returns {boolean} `true` if valid, otherwise `false`\r\n         */\r\n        lxiv.test = function(str) {\r\n            return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(str);\r\n        };\r\n\r\n        return lxiv;\r\n    }();\r\n\r\n    // encodings/base64\r\n\r\n    /**\r\n     * Encodes this ByteBuffer's contents to a base64 encoded string.\r\n     * @param {number=} begin Offset to begin at, defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}.\r\n     * @returns {string} Base64 encoded string\r\n     * @throws {RangeError} If `begin` or `end` is out of bounds\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toBase64 = function(begin, end) {\r\n        if (typeof begin === 'undefined')\r\n            begin = this.offset;\r\n        if (typeof end === 'undefined')\r\n            end = this.limit;\r\n        begin = begin | 0; end = end | 0;\r\n        if (begin < 0 || end > this.capacity || begin > end)\r\n            throw RangeError(\"begin, end\");\r\n        var sd; lxiv.encode(function() {\r\n            return begin < end ? this.view[begin++] : null;\r\n        }.bind(this), sd = stringDestination());\r\n        return sd();\r\n    };\r\n\r\n    /**\r\n     * Decodes a base64 encoded string to a ByteBuffer.\r\n     * @param {string} str String to decode\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.fromBase64 = function(str, littleEndian) {\r\n        if (typeof str !== 'string')\r\n            throw TypeError(\"str\");\r\n        var bb = new ByteBuffer(str.length/4*3, littleEndian),\r\n            i = 0;\r\n        lxiv.decode(stringSource(str), function(b) {\r\n            bb.view[i++] = b;\r\n        });\r\n        bb.limit = i;\r\n        return bb;\r\n    };\r\n\r\n    /**\r\n     * Encodes a binary string to base64 like `window.btoa` does.\r\n     * @param {string} str Binary string\r\n     * @returns {string} Base64 encoded string\r\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.btoa\r\n     * @expose\r\n     */\r\n    ByteBuffer.btoa = function(str) {\r\n        return ByteBuffer.fromBinary(str).toBase64();\r\n    };\r\n\r\n    /**\r\n     * Decodes a base64 encoded string to binary like `window.atob` does.\r\n     * @param {string} b64 Base64 encoded string\r\n     * @returns {string} Binary string\r\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.atob\r\n     * @expose\r\n     */\r\n    ByteBuffer.atob = function(b64) {\r\n        return ByteBuffer.fromBase64(b64).toBinary();\r\n    };\r\n\r\n    // encodings/binary\r\n\r\n    /**\r\n     * Encodes this ByteBuffer to a binary encoded string, that is using only characters 0x00-0xFF as bytes.\r\n     * @param {number=} begin Offset to begin at. Defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end Offset to end at. Defaults to {@link ByteBuffer#limit}.\r\n     * @returns {string} Binary encoded string\r\n     * @throws {RangeError} If `offset > limit`\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toBinary = function(begin, end) {\r\n        if (typeof begin === 'undefined')\r\n            begin = this.offset;\r\n        if (typeof end === 'undefined')\r\n            end = this.limit;\r\n        begin |= 0; end |= 0;\r\n        if (begin < 0 || end > this.capacity() || begin > end)\r\n            throw RangeError(\"begin, end\");\r\n        if (begin === end)\r\n            return \"\";\r\n        var chars = [],\r\n            parts = [];\r\n        while (begin < end) {\r\n            chars.push(this.view[begin++]);\r\n            if (chars.length >= 1024)\r\n                parts.push(String.fromCharCode.apply(String, chars)),\r\n                chars = [];\r\n        }\r\n        return parts.join('') + String.fromCharCode.apply(String, chars);\r\n    };\r\n\r\n    /**\r\n     * Decodes a binary encoded string, that is using only characters 0x00-0xFF as bytes, to a ByteBuffer.\r\n     * @param {string} str String to decode\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.fromBinary = function(str, littleEndian) {\r\n        if (typeof str !== 'string')\r\n            throw TypeError(\"str\");\r\n        var i = 0,\r\n            k = str.length,\r\n            charCode,\r\n            bb = new ByteBuffer(k, littleEndian);\r\n        while (i<k) {\r\n            charCode = str.charCodeAt(i);\r\n            if (charCode > 0xff)\r\n                throw RangeError(\"illegal char code: \"+charCode);\r\n            bb.view[i++] = charCode;\r\n        }\r\n        bb.limit = k;\r\n        return bb;\r\n    };\r\n\r\n    // encodings/debug\r\n\r\n    /**\r\n     * Encodes this ByteBuffer to a hex encoded string with marked offsets. Offset symbols are:\r\n     * * `<` : offset,\r\n     * * `'` : markedOffset,\r\n     * * `>` : limit,\r\n     * * `|` : offset and limit,\r\n     * * `[` : offset and markedOffset,\r\n     * * `]` : markedOffset and limit,\r\n     * * `!` : offset, markedOffset and limit\r\n     * @param {boolean=} columns If `true` returns two columns hex + ascii, defaults to `false`\r\n     * @returns {string|!Array.<string>} Debug string or array of lines if `asArray = true`\r\n     * @expose\r\n     * @example `>00'01 02<03` contains four bytes with `limit=0, markedOffset=1, offset=3`\r\n     * @example `00[01 02 03>` contains four bytes with `offset=markedOffset=1, limit=4`\r\n     * @example `00|01 02 03` contains four bytes with `offset=limit=1, markedOffset=-1`\r\n     * @example `|` contains zero bytes with `offset=limit=0, markedOffset=-1`\r\n     */\r\n    ByteBufferPrototype.toDebug = function(columns) {\r\n        var i = -1,\r\n            k = this.buffer.byteLength,\r\n            b,\r\n            hex = \"\",\r\n            asc = \"\",\r\n            out = \"\";\r\n        while (i<k) {\r\n            if (i !== -1) {\r\n                b = this.view[i];\r\n                if (b < 0x10) hex += \"0\"+b.toString(16).toUpperCase();\r\n                else hex += b.toString(16).toUpperCase();\r\n                if (columns)\r\n                    asc += b > 32 && b < 127 ? String.fromCharCode(b) : '.';\r\n            }\r\n            ++i;\r\n            if (columns) {\r\n                if (i > 0 && i % 16 === 0 && i !== k) {\r\n                    while (hex.length < 3*16+3) hex += \" \";\r\n                    out += hex+asc+\"\\n\";\r\n                    hex = asc = \"\";\r\n                }\r\n            }\r\n            if (i === this.offset && i === this.limit)\r\n                hex += i === this.markedOffset ? \"!\" : \"|\";\r\n            else if (i === this.offset)\r\n                hex += i === this.markedOffset ? \"[\" : \"<\";\r\n            else if (i === this.limit)\r\n                hex += i === this.markedOffset ? \"]\" : \">\";\r\n            else\r\n                hex += i === this.markedOffset ? \"'\" : (columns || (i !== 0 && i !== k) ? \" \" : \"\");\r\n        }\r\n        if (columns && hex !== \" \") {\r\n            while (hex.length < 3*16+3)\r\n                hex += \" \";\r\n            out += hex + asc + \"\\n\";\r\n        }\r\n        return columns ? out : hex;\r\n    };\r\n\r\n    /**\r\n     * Decodes a hex encoded string with marked offsets to a ByteBuffer.\r\n     * @param {string} str Debug string to decode (not be generated with `columns = true`)\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     * @see ByteBuffer#toDebug\r\n     */\r\n    ByteBuffer.fromDebug = function(str, littleEndian, noAssert) {\r\n        var k = str.length,\r\n            bb = new ByteBuffer(((k+1)/3)|0, littleEndian, noAssert);\r\n        var i = 0, j = 0, ch, b,\r\n            rs = false, // Require symbol next\r\n            ho = false, hm = false, hl = false, // Already has offset (ho), markedOffset (hm), limit (hl)?\r\n            fail = false;\r\n        while (i<k) {\r\n            switch (ch = str.charAt(i++)) {\r\n                case '!':\r\n                    if (!noAssert) {\r\n                        if (ho || hm || hl) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        ho = hm = hl = true;\r\n                    }\r\n                    bb.offset = bb.markedOffset = bb.limit = j;\r\n                    rs = false;\r\n                    break;\r\n                case '|':\r\n                    if (!noAssert) {\r\n                        if (ho || hl) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        ho = hl = true;\r\n                    }\r\n                    bb.offset = bb.limit = j;\r\n                    rs = false;\r\n                    break;\r\n                case '[':\r\n                    if (!noAssert) {\r\n                        if (ho || hm) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        ho = hm = true;\r\n                    }\r\n                    bb.offset = bb.markedOffset = j;\r\n                    rs = false;\r\n                    break;\r\n                case '<':\r\n                    if (!noAssert) {\r\n                        if (ho) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        ho = true;\r\n                    }\r\n                    bb.offset = j;\r\n                    rs = false;\r\n                    break;\r\n                case ']':\r\n                    if (!noAssert) {\r\n                        if (hl || hm) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        hl = hm = true;\r\n                    }\r\n                    bb.limit = bb.markedOffset = j;\r\n                    rs = false;\r\n                    break;\r\n                case '>':\r\n                    if (!noAssert) {\r\n                        if (hl) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        hl = true;\r\n                    }\r\n                    bb.limit = j;\r\n                    rs = false;\r\n                    break;\r\n                case \"'\":\r\n                    if (!noAssert) {\r\n                        if (hm) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                        hm = true;\r\n                    }\r\n                    bb.markedOffset = j;\r\n                    rs = false;\r\n                    break;\r\n                case ' ':\r\n                    rs = false;\r\n                    break;\r\n                default:\r\n                    if (!noAssert) {\r\n                        if (rs) {\r\n                            fail = true;\r\n                            break;\r\n                        }\r\n                    }\r\n                    b = parseInt(ch+str.charAt(i++), 16);\r\n                    if (!noAssert) {\r\n                        if (isNaN(b) || b < 0 || b > 255)\r\n                            throw TypeError(\"Illegal str: Not a debug encoded string\");\r\n                    }\r\n                    bb.view[j++] = b;\r\n                    rs = true;\r\n            }\r\n            if (fail)\r\n                throw TypeError(\"Illegal str: Invalid symbol at \"+i);\r\n        }\r\n        if (!noAssert) {\r\n            if (!ho || !hl)\r\n                throw TypeError(\"Illegal str: Missing offset or limit\");\r\n            if (j<bb.buffer.byteLength)\r\n                throw TypeError(\"Illegal str: Not a debug encoded string (is it hex?) \"+j+\" < \"+k);\r\n        }\r\n        return bb;\r\n    };\r\n\r\n    // encodings/hex\r\n\r\n    /**\r\n     * Encodes this ByteBuffer's contents to a hex encoded string.\r\n     * @param {number=} begin Offset to begin at. Defaults to {@link ByteBuffer#offset}.\r\n     * @param {number=} end Offset to end at. Defaults to {@link ByteBuffer#limit}.\r\n     * @returns {string} Hex encoded string\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toHex = function(begin, end) {\r\n        begin = typeof begin === 'undefined' ? this.offset : begin;\r\n        end = typeof end === 'undefined' ? this.limit : end;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        var out = new Array(end - begin),\r\n            b;\r\n        while (begin < end) {\r\n            b = this.view[begin++];\r\n            if (b < 0x10)\r\n                out.push(\"0\", b.toString(16));\r\n            else out.push(b.toString(16));\r\n        }\r\n        return out.join('');\r\n    };\r\n\r\n    /**\r\n     * Decodes a hex encoded string to a ByteBuffer.\r\n     * @param {string} str String to decode\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.fromHex = function(str, littleEndian, noAssert) {\r\n        if (!noAssert) {\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n            if (str.length % 2 !== 0)\r\n                throw TypeError(\"Illegal str: Length not a multiple of 2\");\r\n        }\r\n        var k = str.length,\r\n            bb = new ByteBuffer((k / 2) | 0, littleEndian),\r\n            b;\r\n        for (var i=0, j=0; i<k; i+=2) {\r\n            b = parseInt(str.substring(i, i+2), 16);\r\n            if (!noAssert)\r\n                if (!isFinite(b) || b < 0 || b > 255)\r\n                    throw TypeError(\"Illegal str: Contains non-hex characters\");\r\n            bb.view[j++] = b;\r\n        }\r\n        bb.limit = j;\r\n        return bb;\r\n    };\r\n\r\n    // utfx-embeddable\r\n\r\n    /**\r\n     * utfx-embeddable (c) 2014 Daniel Wirtz <dcode@dcode.io>\r\n     * Released under the Apache License, Version 2.0\r\n     * see: https://github.com/dcodeIO/utfx for details\r\n     */\r\n    var utfx = function() {\r\n        \"use strict\";\r\n\r\n        /**\r\n         * utfx namespace.\r\n         * @inner\r\n         * @type {!Object.<string,*>}\r\n         */\r\n        var utfx = {};\r\n\r\n        /**\r\n         * Maximum valid code point.\r\n         * @type {number}\r\n         * @const\r\n         */\r\n        utfx.MAX_CODEPOINT = 0x10FFFF;\r\n\r\n        /**\r\n         * Encodes UTF8 code points to UTF8 bytes.\r\n         * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point\r\n         *  respectively `null` if there are no more code points left or a single numeric code point.\r\n         * @param {!function(number)} dst Bytes destination as a function successively called with the next byte\r\n         */\r\n        utfx.encodeUTF8 = function(src, dst) {\r\n            var cp = null;\r\n            if (typeof src === 'number')\r\n                cp = src,\r\n                src = function() { return null; };\r\n            while (cp !== null || (cp = src()) !== null) {\r\n                if (cp < 0x80)\r\n                    dst(cp&0x7F);\r\n                else if (cp < 0x800)\r\n                    dst(((cp>>6)&0x1F)|0xC0),\r\n                    dst((cp&0x3F)|0x80);\r\n                else if (cp < 0x10000)\r\n                    dst(((cp>>12)&0x0F)|0xE0),\r\n                    dst(((cp>>6)&0x3F)|0x80),\r\n                    dst((cp&0x3F)|0x80);\r\n                else\r\n                    dst(((cp>>18)&0x07)|0xF0),\r\n                    dst(((cp>>12)&0x3F)|0x80),\r\n                    dst(((cp>>6)&0x3F)|0x80),\r\n                    dst((cp&0x3F)|0x80);\r\n                cp = null;\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Decodes UTF8 bytes to UTF8 code points.\r\n         * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if there\r\n         *  are no more bytes left.\r\n         * @param {!function(number)} dst Code points destination as a function successively called with each decoded code point.\r\n         * @throws {RangeError} If a starting byte is invalid in UTF8\r\n         * @throws {Error} If the last sequence is truncated. Has an array property `bytes` holding the\r\n         *  remaining bytes.\r\n         */\r\n        utfx.decodeUTF8 = function(src, dst) {\r\n            var a, b, c, d, fail = function(b) {\r\n                b = b.slice(0, b.indexOf(null));\r\n                var err = Error(b.toString());\r\n                err.name = \"TruncatedError\";\r\n                err['bytes'] = b;\r\n                throw err;\r\n            };\r\n            while ((a = src()) !== null) {\r\n                if ((a&0x80) === 0)\r\n                    dst(a);\r\n                else if ((a&0xE0) === 0xC0)\r\n                    ((b = src()) === null) && fail([a, b]),\r\n                    dst(((a&0x1F)<<6) | (b&0x3F));\r\n                else if ((a&0xF0) === 0xE0)\r\n                    ((b=src()) === null || (c=src()) === null) && fail([a, b, c]),\r\n                    dst(((a&0x0F)<<12) | ((b&0x3F)<<6) | (c&0x3F));\r\n                else if ((a&0xF8) === 0xF0)\r\n                    ((b=src()) === null || (c=src()) === null || (d=src()) === null) && fail([a, b, c ,d]),\r\n                    dst(((a&0x07)<<18) | ((b&0x3F)<<12) | ((c&0x3F)<<6) | (d&0x3F));\r\n                else throw RangeError(\"Illegal starting byte: \"+a);\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Converts UTF16 characters to UTF8 code points.\r\n         * @param {!function():number|null} src Characters source as a function returning the next char code respectively\r\n         *  `null` if there are no more characters left.\r\n         * @param {!function(number)} dst Code points destination as a function successively called with each converted code\r\n         *  point.\r\n         */\r\n        utfx.UTF16toUTF8 = function(src, dst) {\r\n            var c1, c2 = null;\r\n            while (true) {\r\n                if ((c1 = c2 !== null ? c2 : src()) === null)\r\n                    break;\r\n                if (c1 >= 0xD800 && c1 <= 0xDFFF) {\r\n                    if ((c2 = src()) !== null) {\r\n                        if (c2 >= 0xDC00 && c2 <= 0xDFFF) {\r\n                            dst((c1-0xD800)*0x400+c2-0xDC00+0x10000);\r\n                            c2 = null; continue;\r\n                        }\r\n                    }\r\n                }\r\n                dst(c1);\r\n            }\r\n            if (c2 !== null) dst(c2);\r\n        };\r\n\r\n        /**\r\n         * Converts UTF8 code points to UTF16 characters.\r\n         * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point\r\n         *  respectively `null` if there are no more code points left or a single numeric code point.\r\n         * @param {!function(number)} dst Characters destination as a function successively called with each converted char code.\r\n         * @throws {RangeError} If a code point is out of range\r\n         */\r\n        utfx.UTF8toUTF16 = function(src, dst) {\r\n            var cp = null;\r\n            if (typeof src === 'number')\r\n                cp = src, src = function() { return null; };\r\n            while (cp !== null || (cp = src()) !== null) {\r\n                if (cp <= 0xFFFF)\r\n                    dst(cp);\r\n                else\r\n                    cp -= 0x10000,\r\n                    dst((cp>>10)+0xD800),\r\n                    dst((cp%0x400)+0xDC00);\r\n                cp = null;\r\n            }\r\n        };\r\n\r\n        /**\r\n         * Converts and encodes UTF16 characters to UTF8 bytes.\r\n         * @param {!function():number|null} src Characters source as a function returning the next char code respectively `null`\r\n         *  if there are no more characters left.\r\n         * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.\r\n         */\r\n        utfx.encodeUTF16toUTF8 = function(src, dst) {\r\n            utfx.UTF16toUTF8(src, function(cp) {\r\n                utfx.encodeUTF8(cp, dst);\r\n            });\r\n        };\r\n\r\n        /**\r\n         * Decodes and converts UTF8 bytes to UTF16 characters.\r\n         * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if there\r\n         *  are no more bytes left.\r\n         * @param {!function(number)} dst Characters destination as a function successively called with each converted char code.\r\n         * @throws {RangeError} If a starting byte is invalid in UTF8\r\n         * @throws {Error} If the last sequence is truncated. Has an array property `bytes` holding the remaining bytes.\r\n         */\r\n        utfx.decodeUTF8toUTF16 = function(src, dst) {\r\n            utfx.decodeUTF8(src, function(cp) {\r\n                utfx.UTF8toUTF16(cp, dst);\r\n            });\r\n        };\r\n\r\n        /**\r\n         * Calculates the byte length of an UTF8 code point.\r\n         * @param {number} cp UTF8 code point\r\n         * @returns {number} Byte length\r\n         */\r\n        utfx.calculateCodePoint = function(cp) {\r\n            return (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;\r\n        };\r\n\r\n        /**\r\n         * Calculates the number of UTF8 bytes required to store UTF8 code points.\r\n         * @param {(!function():number|null)} src Code points source as a function returning the next code point respectively\r\n         *  `null` if there are no more code points left.\r\n         * @returns {number} The number of UTF8 bytes required\r\n         */\r\n        utfx.calculateUTF8 = function(src) {\r\n            var cp, l=0;\r\n            while ((cp = src()) !== null)\r\n                l += (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;\r\n            return l;\r\n        };\r\n\r\n        /**\r\n         * Calculates the number of UTF8 code points respectively UTF8 bytes required to store UTF16 char codes.\r\n         * @param {(!function():number|null)} src Characters source as a function returning the next char code respectively\r\n         *  `null` if there are no more characters left.\r\n         * @returns {!Array.<number>} The number of UTF8 code points at index 0 and the number of UTF8 bytes required at index 1.\r\n         */\r\n        utfx.calculateUTF16asUTF8 = function(src) {\r\n            var n=0, l=0;\r\n            utfx.UTF16toUTF8(src, function(cp) {\r\n                ++n; l += (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;\r\n            });\r\n            return [n,l];\r\n        };\r\n\r\n        return utfx;\r\n    }();\r\n\r\n    // encodings/utf8\r\n\r\n    /**\r\n     * Encodes this ByteBuffer's contents between {@link ByteBuffer#offset} and {@link ByteBuffer#limit} to an UTF8 encoded\r\n     *  string.\r\n     * @returns {string} Hex encoded string\r\n     * @throws {RangeError} If `offset > limit`\r\n     * @expose\r\n     */\r\n    ByteBufferPrototype.toUTF8 = function(begin, end) {\r\n        if (typeof begin === 'undefined') begin = this.offset;\r\n        if (typeof end === 'undefined') end = this.limit;\r\n        if (!this.noAssert) {\r\n            if (typeof begin !== 'number' || begin % 1 !== 0)\n                throw TypeError(\"Illegal begin: Not an integer\");\n            begin >>>= 0;\n            if (typeof end !== 'number' || end % 1 !== 0)\n                throw TypeError(\"Illegal end: Not an integer\");\n            end >>>= 0;\n            if (begin < 0 || begin > end || end > this.buffer.byteLength)\n                throw RangeError(\"Illegal range: 0 <= \"+begin+\" <= \"+end+\" <= \"+this.buffer.byteLength);\n        }\r\n        var sd; try {\r\n            utfx.decodeUTF8toUTF16(function() {\r\n                return begin < end ? this.view[begin++] : null;\r\n            }.bind(this), sd = stringDestination());\r\n        } catch (e) {\r\n            if (begin !== end)\r\n                throw RangeError(\"Illegal range: Truncated data, \"+begin+\" != \"+end);\r\n        }\r\n        return sd();\r\n    };\r\n\r\n    /**\r\n     * Decodes an UTF8 encoded string to a ByteBuffer.\r\n     * @param {string} str String to decode\r\n     * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_ENDIAN}.\r\n     * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to\r\n     *  {@link ByteBuffer.DEFAULT_NOASSERT}.\r\n     * @returns {!ByteBuffer} ByteBuffer\r\n     * @expose\r\n     */\r\n    ByteBuffer.fromUTF8 = function(str, littleEndian, noAssert) {\r\n        if (!noAssert)\r\n            if (typeof str !== 'string')\r\n                throw TypeError(\"Illegal str: Not a string\");\r\n        var bb = new ByteBuffer(utfx.calculateUTF16asUTF8(stringSource(str), true)[1], littleEndian, noAssert),\r\n            i = 0;\r\n        utfx.encodeUTF16toUTF8(stringSource(str), function(b) {\r\n            bb.view[i++] = b;\r\n        });\r\n        bb.limit = i;\r\n        return bb;\r\n    };\r\n\r\n    return ByteBuffer;\r\n});\r\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar objectCreate = Object.create || objectCreatePolyfill\nvar objectKeys = Object.keys || objectKeysPolyfill\nvar bind = Function.prototype.bind || functionBindPolyfill\n\nfunction EventEmitter() {\n  if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {\n    this._events = objectCreate(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nvar hasDefineProperty;\ntry {\n  var o = {};\n  if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });\n  hasDefineProperty = o.x === 0;\n} catch (err) { hasDefineProperty = false }\nif (hasDefineProperty) {\n  Object.defineProperty(EventEmitter, 'defaultMaxListeners', {\n    enumerable: true,\n    get: function() {\n      return defaultMaxListeners;\n    },\n    set: function(arg) {\n      // check whether the input is a positive number (whose value is zero or\n      // greater and not a NaN).\n      if (typeof arg !== 'number' || arg < 0 || arg !== arg)\n        throw new TypeError('\"defaultMaxListeners\" must be a positive number');\n      defaultMaxListeners = arg;\n    }\n  });\n} else {\n  EventEmitter.defaultMaxListeners = defaultMaxListeners;\n}\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || isNaN(n))\n    throw new TypeError('\"n\" argument must be a positive number');\n  this._maxListeners = n;\n  return this;\n};\n\nfunction $getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return $getMaxListeners(this);\n};\n\n// These standalone emit* functions are used to optimize calling of event\n// handlers for fast cases because emit() itself often has a variable number of\n// arguments and can be deoptimized because of that. These functions always have\n// the same number of arguments and thus do not get deoptimized, so the code\n// inside them can execute faster.\nfunction emitNone(handler, isFn, self) {\n  if (isFn)\n    handler.call(self);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].call(self);\n  }\n}\nfunction emitOne(handler, isFn, self, arg1) {\n  if (isFn)\n    handler.call(self, arg1);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].call(self, arg1);\n  }\n}\nfunction emitTwo(handler, isFn, self, arg1, arg2) {\n  if (isFn)\n    handler.call(self, arg1, arg2);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].call(self, arg1, arg2);\n  }\n}\nfunction emitThree(handler, isFn, self, arg1, arg2, arg3) {\n  if (isFn)\n    handler.call(self, arg1, arg2, arg3);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].call(self, arg1, arg2, arg3);\n  }\n}\n\nfunction emitMany(handler, isFn, self, args) {\n  if (isFn)\n    handler.apply(self, args);\n  else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      listeners[i].apply(self, args);\n  }\n}\n\nEventEmitter.prototype.emit = function emit(type) {\n  var er, handler, len, args, i, events;\n  var doError = (type === 'error');\n\n  events = this._events;\n  if (events)\n    doError = (doError && events.error == null);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    if (arguments.length > 1)\n      er = arguments[1];\n    if (er instanceof Error) {\n      throw er; // Unhandled 'error' event\n    } else {\n      // At least give some kind of context to the user\n      var err = new Error('Unhandled \"error\" event. (' + er + ')');\n      err.context = er;\n      throw err;\n    }\n    return false;\n  }\n\n  handler = events[type];\n\n  if (!handler)\n    return false;\n\n  var isFn = typeof handler === 'function';\n  len = arguments.length;\n  switch (len) {\n      // fast cases\n    case 1:\n      emitNone(handler, isFn, this);\n      break;\n    case 2:\n      emitOne(handler, isFn, this, arguments[1]);\n      break;\n    case 3:\n      emitTwo(handler, isFn, this, arguments[1], arguments[2]);\n      break;\n    case 4:\n      emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);\n      break;\n      // slower\n    default:\n      args = new Array(len - 1);\n      for (i = 1; i < len; i++)\n        args[i - 1] = arguments[i];\n      emitMany(handler, isFn, this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  if (typeof listener !== 'function')\n    throw new TypeError('\"listener\" argument must be a function');\n\n  events = target._events;\n  if (!events) {\n    events = target._events = objectCreate(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener) {\n      target.emit('newListener', type,\n          listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (!existing) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n          prepend ? [listener, existing] : [existing, listener];\n    } else {\n      // If we've already got an array, just append.\n      if (prepend) {\n        existing.unshift(listener);\n      } else {\n        existing.push(listener);\n      }\n    }\n\n    // Check for listener leak\n    if (!existing.warned) {\n      m = $getMaxListeners(target);\n      if (m && m > 0 && existing.length > m) {\n        existing.warned = true;\n        var w = new Error('Possible EventEmitter memory leak detected. ' +\n            existing.length + ' \"' + String(type) + '\" listeners ' +\n            'added. Use emitter.setMaxListeners() to ' +\n            'increase limit.');\n        w.name = 'MaxListenersExceededWarning';\n        w.emitter = target;\n        w.type = type;\n        w.count = existing.length;\n        if (typeof console === 'object' && console.warn) {\n          console.warn('%s: %s', w.name, w.message);\n        }\n      }\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    switch (arguments.length) {\n      case 0:\n        return this.listener.call(this.target);\n      case 1:\n        return this.listener.call(this.target, arguments[0]);\n      case 2:\n        return this.listener.call(this.target, arguments[0], arguments[1]);\n      case 3:\n        return this.listener.call(this.target, arguments[0], arguments[1],\n            arguments[2]);\n      default:\n        var args = new Array(arguments.length);\n        for (var i = 0; i < args.length; ++i)\n          args[i] = arguments[i];\n        this.listener.apply(this.target, args);\n    }\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = bind.call(onceWrapper, state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  if (typeof listener !== 'function')\n    throw new TypeError('\"listener\" argument must be a function');\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      if (typeof listener !== 'function')\n        throw new TypeError('\"listener\" argument must be a function');\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      if (typeof listener !== 'function')\n        throw new TypeError('\"listener\" argument must be a function');\n\n      events = this._events;\n      if (!events)\n        return this;\n\n      list = events[type];\n      if (!list)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = objectCreate(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else\n          spliceOne(list, position);\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (!events)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (!events.removeListener) {\n        if (arguments.length === 0) {\n          this._events = objectCreate(null);\n          this._eventsCount = 0;\n        } else if (events[type]) {\n          if (--this._eventsCount === 0)\n            this._events = objectCreate(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = objectKeys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = objectCreate(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (!events)\n    return [];\n\n  var evlistener = events[type];\n  if (!evlistener)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];\n};\n\n// About 1.5x faster than the two-arg version of Array#splice().\nfunction spliceOne(list, index) {\n  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)\n    list[i] = list[k];\n  list.pop();\n}\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction objectCreatePolyfill(proto) {\n  var F = function() {};\n  F.prototype = proto;\n  return new F;\n}\nfunction objectKeysPolyfill(obj) {\n  var keys = [];\n  for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) {\n    keys.push(k);\n  }\n  return k;\n}\nfunction functionBindPolyfill(context) {\n  var fn = this;\n  return function () {\n    return fn.apply(context, arguments);\n  };\n}\n","var http = require('http')\nvar url = require('url')\n\nvar https = module.exports\n\nfor (var key in http) {\n  if (http.hasOwnProperty(key)) https[key] = http[key]\n}\n\nhttps.request = function (params, cb) {\n  params = validateParams(params)\n  return http.request.call(this, params, cb)\n}\n\nhttps.get = function (params, cb) {\n  params = validateParams(params)\n  return http.get.call(this, params, cb)\n}\n\nfunction validateParams (params) {\n  if (typeof params === 'string') {\n    params = url.parse(params)\n  }\n  if (!params.protocol) {\n    params.protocol = 'https:'\n  }\n  if (params.protocol !== 'https:') {\n    throw new Error('Protocol \"' + params.protocol + '\" not supported. Expected \"https:\"')\n  }\n  return params\n}\n","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\nexports.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","/**\n * MIT License\n * \n * Copyright (c) 2014-present, Lee Byron and other contributors.\n * \n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n * \n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n * \n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\n  typeof define === 'function' && define.amd ? define(['exports'], factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Immutable = {}));\n}(this, (function (exports) { 'use strict';\n\n  var DELETE = 'delete';\n\n  // Constants describing the size of trie nodes.\n  var SHIFT = 5; // Resulted in best performance after ______?\n  var SIZE = 1 << SHIFT;\n  var MASK = SIZE - 1;\n\n  // A consistent shared value representing \"not set\" which equals nothing other\n  // than itself, and nothing that could be provided externally.\n  var NOT_SET = {};\n\n  // Boolean references, Rough equivalent of `bool &`.\n  function MakeRef() {\n    return { value: false };\n  }\n\n  function SetRef(ref) {\n    if (ref) {\n      ref.value = true;\n    }\n  }\n\n  // A function which returns a value representing an \"owner\" for transient writes\n  // to tries. The return value will only ever equal itself, and will not equal\n  // the return of any subsequent call of this function.\n  function OwnerID() {}\n\n  function ensureSize(iter) {\n    if (iter.size === undefined) {\n      iter.size = iter.__iterate(returnTrue);\n    }\n    return iter.size;\n  }\n\n  function wrapIndex(iter, index) {\n    // This implements \"is array index\" which the ECMAString spec defines as:\n    //\n    //     A String property name P is an array index if and only if\n    //     ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal\n    //     to 2^32−1.\n    //\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects\n    if (typeof index !== 'number') {\n      var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32\n      if ('' + uint32Index !== index || uint32Index === 4294967295) {\n        return NaN;\n      }\n      index = uint32Index;\n    }\n    return index < 0 ? ensureSize(iter) + index : index;\n  }\n\n  function returnTrue() {\n    return true;\n  }\n\n  function wholeSlice(begin, end, size) {\n    return (\n      ((begin === 0 && !isNeg(begin)) ||\n        (size !== undefined && begin <= -size)) &&\n      (end === undefined || (size !== undefined && end >= size))\n    );\n  }\n\n  function resolveBegin(begin, size) {\n    return resolveIndex(begin, size, 0);\n  }\n\n  function resolveEnd(end, size) {\n    return resolveIndex(end, size, size);\n  }\n\n  function resolveIndex(index, size, defaultIndex) {\n    // Sanitize indices using this shorthand for ToInt32(argument)\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32\n    return index === undefined\n      ? defaultIndex\n      : isNeg(index)\n      ? size === Infinity\n        ? size\n        : Math.max(0, size + index) | 0\n      : size === undefined || size === index\n      ? index\n      : Math.min(size, index) | 0;\n  }\n\n  function isNeg(value) {\n    // Account for -0 which is negative, but not less than 0.\n    return value < 0 || (value === 0 && 1 / value === -Infinity);\n  }\n\n  var IS_COLLECTION_SYMBOL = '@@__IMMUTABLE_ITERABLE__@@';\n\n  function isCollection(maybeCollection) {\n    return Boolean(maybeCollection && maybeCollection[IS_COLLECTION_SYMBOL]);\n  }\n\n  var IS_KEYED_SYMBOL = '@@__IMMUTABLE_KEYED__@@';\n\n  function isKeyed(maybeKeyed) {\n    return Boolean(maybeKeyed && maybeKeyed[IS_KEYED_SYMBOL]);\n  }\n\n  var IS_INDEXED_SYMBOL = '@@__IMMUTABLE_INDEXED__@@';\n\n  function isIndexed(maybeIndexed) {\n    return Boolean(maybeIndexed && maybeIndexed[IS_INDEXED_SYMBOL]);\n  }\n\n  function isAssociative(maybeAssociative) {\n    return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);\n  }\n\n  var Collection = function Collection(value) {\n    return isCollection(value) ? value : Seq(value);\n  };\n\n  var KeyedCollection = /*@__PURE__*/(function (Collection) {\n    function KeyedCollection(value) {\n      return isKeyed(value) ? value : KeyedSeq(value);\n    }\n\n    if ( Collection ) KeyedCollection.__proto__ = Collection;\n    KeyedCollection.prototype = Object.create( Collection && Collection.prototype );\n    KeyedCollection.prototype.constructor = KeyedCollection;\n\n    return KeyedCollection;\n  }(Collection));\n\n  var IndexedCollection = /*@__PURE__*/(function (Collection) {\n    function IndexedCollection(value) {\n      return isIndexed(value) ? value : IndexedSeq(value);\n    }\n\n    if ( Collection ) IndexedCollection.__proto__ = Collection;\n    IndexedCollection.prototype = Object.create( Collection && Collection.prototype );\n    IndexedCollection.prototype.constructor = IndexedCollection;\n\n    return IndexedCollection;\n  }(Collection));\n\n  var SetCollection = /*@__PURE__*/(function (Collection) {\n    function SetCollection(value) {\n      return isCollection(value) && !isAssociative(value) ? value : SetSeq(value);\n    }\n\n    if ( Collection ) SetCollection.__proto__ = Collection;\n    SetCollection.prototype = Object.create( Collection && Collection.prototype );\n    SetCollection.prototype.constructor = SetCollection;\n\n    return SetCollection;\n  }(Collection));\n\n  Collection.Keyed = KeyedCollection;\n  Collection.Indexed = IndexedCollection;\n  Collection.Set = SetCollection;\n\n  var IS_SEQ_SYMBOL = '@@__IMMUTABLE_SEQ__@@';\n\n  function isSeq(maybeSeq) {\n    return Boolean(maybeSeq && maybeSeq[IS_SEQ_SYMBOL]);\n  }\n\n  var IS_RECORD_SYMBOL = '@@__IMMUTABLE_RECORD__@@';\n\n  function isRecord(maybeRecord) {\n    return Boolean(maybeRecord && maybeRecord[IS_RECORD_SYMBOL]);\n  }\n\n  function isImmutable(maybeImmutable) {\n    return isCollection(maybeImmutable) || isRecord(maybeImmutable);\n  }\n\n  var IS_ORDERED_SYMBOL = '@@__IMMUTABLE_ORDERED__@@';\n\n  function isOrdered(maybeOrdered) {\n    return Boolean(maybeOrdered && maybeOrdered[IS_ORDERED_SYMBOL]);\n  }\n\n  var ITERATE_KEYS = 0;\n  var ITERATE_VALUES = 1;\n  var ITERATE_ENTRIES = 2;\n\n  var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n  var FAUX_ITERATOR_SYMBOL = '@@iterator';\n\n  var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;\n\n  var Iterator = function Iterator(next) {\n    this.next = next;\n  };\n\n  Iterator.prototype.toString = function toString () {\n    return '[Iterator]';\n  };\n\n  Iterator.KEYS = ITERATE_KEYS;\n  Iterator.VALUES = ITERATE_VALUES;\n  Iterator.ENTRIES = ITERATE_ENTRIES;\n\n  Iterator.prototype.inspect = Iterator.prototype.toSource = function () {\n    return this.toString();\n  };\n  Iterator.prototype[ITERATOR_SYMBOL] = function () {\n    return this;\n  };\n\n  function iteratorValue(type, k, v, iteratorResult) {\n    var value = type === 0 ? k : type === 1 ? v : [k, v];\n    iteratorResult\n      ? (iteratorResult.value = value)\n      : (iteratorResult = {\n          value: value,\n          done: false,\n        });\n    return iteratorResult;\n  }\n\n  function iteratorDone() {\n    return { value: undefined, done: true };\n  }\n\n  function hasIterator(maybeIterable) {\n    if (Array.isArray(maybeIterable)) {\n      // IE11 trick as it does not support `Symbol.iterator`\n      return true;\n    }\n\n    return !!getIteratorFn(maybeIterable);\n  }\n\n  function isIterator(maybeIterator) {\n    return maybeIterator && typeof maybeIterator.next === 'function';\n  }\n\n  function getIterator(iterable) {\n    var iteratorFn = getIteratorFn(iterable);\n    return iteratorFn && iteratorFn.call(iterable);\n  }\n\n  function getIteratorFn(iterable) {\n    var iteratorFn =\n      iterable &&\n      ((REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||\n        iterable[FAUX_ITERATOR_SYMBOL]);\n    if (typeof iteratorFn === 'function') {\n      return iteratorFn;\n    }\n  }\n\n  function isEntriesIterable(maybeIterable) {\n    var iteratorFn = getIteratorFn(maybeIterable);\n    return iteratorFn && iteratorFn === maybeIterable.entries;\n  }\n\n  function isKeysIterable(maybeIterable) {\n    var iteratorFn = getIteratorFn(maybeIterable);\n    return iteratorFn && iteratorFn === maybeIterable.keys;\n  }\n\n  var hasOwnProperty = Object.prototype.hasOwnProperty;\n\n  function isArrayLike(value) {\n    if (Array.isArray(value) || typeof value === 'string') {\n      return true;\n    }\n\n    return (\n      value &&\n      typeof value === 'object' &&\n      Number.isInteger(value.length) &&\n      value.length >= 0 &&\n      (value.length === 0\n        ? // Only {length: 0} is considered Array-like.\n          Object.keys(value).length === 1\n        : // An object is only Array-like if it has a property where the last value\n          // in the array-like may be found (which could be undefined).\n          value.hasOwnProperty(value.length - 1))\n    );\n  }\n\n  var Seq = /*@__PURE__*/(function (Collection) {\n    function Seq(value) {\n      return value === undefined || value === null\n        ? emptySequence()\n        : isImmutable(value)\n        ? value.toSeq()\n        : seqFromValue(value);\n    }\n\n    if ( Collection ) Seq.__proto__ = Collection;\n    Seq.prototype = Object.create( Collection && Collection.prototype );\n    Seq.prototype.constructor = Seq;\n\n    Seq.prototype.toSeq = function toSeq () {\n      return this;\n    };\n\n    Seq.prototype.toString = function toString () {\n      return this.__toString('Seq {', '}');\n    };\n\n    Seq.prototype.cacheResult = function cacheResult () {\n      if (!this._cache && this.__iterateUncached) {\n        this._cache = this.entrySeq().toArray();\n        this.size = this._cache.length;\n      }\n      return this;\n    };\n\n    // abstract __iterateUncached(fn, reverse)\n\n    Seq.prototype.__iterate = function __iterate (fn, reverse) {\n      var cache = this._cache;\n      if (cache) {\n        var size = cache.length;\n        var i = 0;\n        while (i !== size) {\n          var entry = cache[reverse ? size - ++i : i++];\n          if (fn(entry[1], entry[0], this) === false) {\n            break;\n          }\n        }\n        return i;\n      }\n      return this.__iterateUncached(fn, reverse);\n    };\n\n    // abstract __iteratorUncached(type, reverse)\n\n    Seq.prototype.__iterator = function __iterator (type, reverse) {\n      var cache = this._cache;\n      if (cache) {\n        var size = cache.length;\n        var i = 0;\n        return new Iterator(function () {\n          if (i === size) {\n            return iteratorDone();\n          }\n          var entry = cache[reverse ? size - ++i : i++];\n          return iteratorValue(type, entry[0], entry[1]);\n        });\n      }\n      return this.__iteratorUncached(type, reverse);\n    };\n\n    return Seq;\n  }(Collection));\n\n  var KeyedSeq = /*@__PURE__*/(function (Seq) {\n    function KeyedSeq(value) {\n      return value === undefined || value === null\n        ? emptySequence().toKeyedSeq()\n        : isCollection(value)\n        ? isKeyed(value)\n          ? value.toSeq()\n          : value.fromEntrySeq()\n        : isRecord(value)\n        ? value.toSeq()\n        : keyedSeqFromValue(value);\n    }\n\n    if ( Seq ) KeyedSeq.__proto__ = Seq;\n    KeyedSeq.prototype = Object.create( Seq && Seq.prototype );\n    KeyedSeq.prototype.constructor = KeyedSeq;\n\n    KeyedSeq.prototype.toKeyedSeq = function toKeyedSeq () {\n      return this;\n    };\n\n    return KeyedSeq;\n  }(Seq));\n\n  var IndexedSeq = /*@__PURE__*/(function (Seq) {\n    function IndexedSeq(value) {\n      return value === undefined || value === null\n        ? emptySequence()\n        : isCollection(value)\n        ? isKeyed(value)\n          ? value.entrySeq()\n          : value.toIndexedSeq()\n        : isRecord(value)\n        ? value.toSeq().entrySeq()\n        : indexedSeqFromValue(value);\n    }\n\n    if ( Seq ) IndexedSeq.__proto__ = Seq;\n    IndexedSeq.prototype = Object.create( Seq && Seq.prototype );\n    IndexedSeq.prototype.constructor = IndexedSeq;\n\n    IndexedSeq.of = function of (/*...values*/) {\n      return IndexedSeq(arguments);\n    };\n\n    IndexedSeq.prototype.toIndexedSeq = function toIndexedSeq () {\n      return this;\n    };\n\n    IndexedSeq.prototype.toString = function toString () {\n      return this.__toString('Seq [', ']');\n    };\n\n    return IndexedSeq;\n  }(Seq));\n\n  var SetSeq = /*@__PURE__*/(function (Seq) {\n    function SetSeq(value) {\n      return (\n        isCollection(value) && !isAssociative(value) ? value : IndexedSeq(value)\n      ).toSetSeq();\n    }\n\n    if ( Seq ) SetSeq.__proto__ = Seq;\n    SetSeq.prototype = Object.create( Seq && Seq.prototype );\n    SetSeq.prototype.constructor = SetSeq;\n\n    SetSeq.of = function of (/*...values*/) {\n      return SetSeq(arguments);\n    };\n\n    SetSeq.prototype.toSetSeq = function toSetSeq () {\n      return this;\n    };\n\n    return SetSeq;\n  }(Seq));\n\n  Seq.isSeq = isSeq;\n  Seq.Keyed = KeyedSeq;\n  Seq.Set = SetSeq;\n  Seq.Indexed = IndexedSeq;\n\n  Seq.prototype[IS_SEQ_SYMBOL] = true;\n\n  // #pragma Root Sequences\n\n  var ArraySeq = /*@__PURE__*/(function (IndexedSeq) {\n    function ArraySeq(array) {\n      this._array = array;\n      this.size = array.length;\n    }\n\n    if ( IndexedSeq ) ArraySeq.__proto__ = IndexedSeq;\n    ArraySeq.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );\n    ArraySeq.prototype.constructor = ArraySeq;\n\n    ArraySeq.prototype.get = function get (index, notSetValue) {\n      return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue;\n    };\n\n    ArraySeq.prototype.__iterate = function __iterate (fn, reverse) {\n      var array = this._array;\n      var size = array.length;\n      var i = 0;\n      while (i !== size) {\n        var ii = reverse ? size - ++i : i++;\n        if (fn(array[ii], ii, this) === false) {\n          break;\n        }\n      }\n      return i;\n    };\n\n    ArraySeq.prototype.__iterator = function __iterator (type, reverse) {\n      var array = this._array;\n      var size = array.length;\n      var i = 0;\n      return new Iterator(function () {\n        if (i === size) {\n          return iteratorDone();\n        }\n        var ii = reverse ? size - ++i : i++;\n        return iteratorValue(type, ii, array[ii]);\n      });\n    };\n\n    return ArraySeq;\n  }(IndexedSeq));\n\n  var ObjectSeq = /*@__PURE__*/(function (KeyedSeq) {\n    function ObjectSeq(object) {\n      var keys = Object.keys(object).concat(\n        Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : []\n      );\n      this._object = object;\n      this._keys = keys;\n      this.size = keys.length;\n    }\n\n    if ( KeyedSeq ) ObjectSeq.__proto__ = KeyedSeq;\n    ObjectSeq.prototype = Object.create( KeyedSeq && KeyedSeq.prototype );\n    ObjectSeq.prototype.constructor = ObjectSeq;\n\n    ObjectSeq.prototype.get = function get (key, notSetValue) {\n      if (notSetValue !== undefined && !this.has(key)) {\n        return notSetValue;\n      }\n      return this._object[key];\n    };\n\n    ObjectSeq.prototype.has = function has (key) {\n      return hasOwnProperty.call(this._object, key);\n    };\n\n    ObjectSeq.prototype.__iterate = function __iterate (fn, reverse) {\n      var object = this._object;\n      var keys = this._keys;\n      var size = keys.length;\n      var i = 0;\n      while (i !== size) {\n        var key = keys[reverse ? size - ++i : i++];\n        if (fn(object[key], key, this) === false) {\n          break;\n        }\n      }\n      return i;\n    };\n\n    ObjectSeq.prototype.__iterator = function __iterator (type, reverse) {\n      var object = this._object;\n      var keys = this._keys;\n      var size = keys.length;\n      var i = 0;\n      return new Iterator(function () {\n        if (i === size) {\n          return iteratorDone();\n        }\n        var key = keys[reverse ? size - ++i : i++];\n        return iteratorValue(type, key, object[key]);\n      });\n    };\n\n    return ObjectSeq;\n  }(KeyedSeq));\n  ObjectSeq.prototype[IS_ORDERED_SYMBOL] = true;\n\n  var CollectionSeq = /*@__PURE__*/(function (IndexedSeq) {\n    function CollectionSeq(collection) {\n      this._collection = collection;\n      this.size = collection.length || collection.size;\n    }\n\n    if ( IndexedSeq ) CollectionSeq.__proto__ = IndexedSeq;\n    CollectionSeq.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );\n    CollectionSeq.prototype.constructor = CollectionSeq;\n\n    CollectionSeq.prototype.__iterateUncached = function __iterateUncached (fn, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var collection = this._collection;\n      var iterator = getIterator(collection);\n      var iterations = 0;\n      if (isIterator(iterator)) {\n        var step;\n        while (!(step = iterator.next()).done) {\n          if (fn(step.value, iterations++, this) === false) {\n            break;\n          }\n        }\n      }\n      return iterations;\n    };\n\n    CollectionSeq.prototype.__iteratorUncached = function __iteratorUncached (type, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var collection = this._collection;\n      var iterator = getIterator(collection);\n      if (!isIterator(iterator)) {\n        return new Iterator(iteratorDone);\n      }\n      var iterations = 0;\n      return new Iterator(function () {\n        var step = iterator.next();\n        return step.done ? step : iteratorValue(type, iterations++, step.value);\n      });\n    };\n\n    return CollectionSeq;\n  }(IndexedSeq));\n\n  // # pragma Helper functions\n\n  var EMPTY_SEQ;\n\n  function emptySequence() {\n    return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));\n  }\n\n  function keyedSeqFromValue(value) {\n    var seq = maybeIndexedSeqFromValue(value);\n    if (seq) {\n      return seq.fromEntrySeq();\n    }\n    if (typeof value === 'object') {\n      return new ObjectSeq(value);\n    }\n    throw new TypeError(\n      'Expected Array or collection object of [k, v] entries, or keyed object: ' +\n        value\n    );\n  }\n\n  function indexedSeqFromValue(value) {\n    var seq = maybeIndexedSeqFromValue(value);\n    if (seq) {\n      return seq;\n    }\n    throw new TypeError(\n      'Expected Array or collection object of values: ' + value\n    );\n  }\n\n  function seqFromValue(value) {\n    var seq = maybeIndexedSeqFromValue(value);\n    if (seq) {\n      return isEntriesIterable(value)\n        ? seq.fromEntrySeq()\n        : isKeysIterable(value)\n        ? seq.toSetSeq()\n        : seq;\n    }\n    if (typeof value === 'object') {\n      return new ObjectSeq(value);\n    }\n    throw new TypeError(\n      'Expected Array or collection object of values, or keyed object: ' + value\n    );\n  }\n\n  function maybeIndexedSeqFromValue(value) {\n    return isArrayLike(value)\n      ? new ArraySeq(value)\n      : hasIterator(value)\n      ? new CollectionSeq(value)\n      : undefined;\n  }\n\n  var IS_MAP_SYMBOL = '@@__IMMUTABLE_MAP__@@';\n\n  function isMap(maybeMap) {\n    return Boolean(maybeMap && maybeMap[IS_MAP_SYMBOL]);\n  }\n\n  function isOrderedMap(maybeOrderedMap) {\n    return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);\n  }\n\n  function isValueObject(maybeValue) {\n    return Boolean(\n      maybeValue &&\n        typeof maybeValue.equals === 'function' &&\n        typeof maybeValue.hashCode === 'function'\n    );\n  }\n\n  /**\n   * An extension of the \"same-value\" algorithm as [described for use by ES6 Map\n   * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)\n   *\n   * NaN is considered the same as NaN, however -0 and 0 are considered the same\n   * value, which is different from the algorithm described by\n   * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).\n   *\n   * This is extended further to allow Objects to describe the values they\n   * represent, by way of `valueOf` or `equals` (and `hashCode`).\n   *\n   * Note: because of this extension, the key equality of Immutable.Map and the\n   * value equality of Immutable.Set will differ from ES6 Map and Set.\n   *\n   * ### Defining custom values\n   *\n   * The easiest way to describe the value an object represents is by implementing\n   * `valueOf`. For example, `Date` represents a value by returning a unix\n   * timestamp for `valueOf`:\n   *\n   *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...\n   *     var date2 = new Date(1234567890000);\n   *     date1.valueOf(); // 1234567890000\n   *     assert( date1 !== date2 );\n   *     assert( Immutable.is( date1, date2 ) );\n   *\n   * Note: overriding `valueOf` may have other implications if you use this object\n   * where JavaScript expects a primitive, such as implicit string coercion.\n   *\n   * For more complex types, especially collections, implementing `valueOf` may\n   * not be performant. An alternative is to implement `equals` and `hashCode`.\n   *\n   * `equals` takes another object, presumably of similar type, and returns true\n   * if it is equal. Equality is symmetrical, so the same result should be\n   * returned if this and the argument are flipped.\n   *\n   *     assert( a.equals(b) === b.equals(a) );\n   *\n   * `hashCode` returns a 32bit integer number representing the object which will\n   * be used to determine how to store the value object in a Map or Set. You must\n   * provide both or neither methods, one must not exist without the other.\n   *\n   * Also, an important relationship between these methods must be upheld: if two\n   * values are equal, they *must* return the same hashCode. If the values are not\n   * equal, they might have the same hashCode; this is called a hash collision,\n   * and while undesirable for performance reasons, it is acceptable.\n   *\n   *     if (a.equals(b)) {\n   *       assert( a.hashCode() === b.hashCode() );\n   *     }\n   *\n   * All Immutable collections are Value Objects: they implement `equals()`\n   * and `hashCode()`.\n   */\n  function is(valueA, valueB) {\n    if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {\n      return true;\n    }\n    if (!valueA || !valueB) {\n      return false;\n    }\n    if (\n      typeof valueA.valueOf === 'function' &&\n      typeof valueB.valueOf === 'function'\n    ) {\n      valueA = valueA.valueOf();\n      valueB = valueB.valueOf();\n      if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {\n        return true;\n      }\n      if (!valueA || !valueB) {\n        return false;\n      }\n    }\n    return !!(\n      isValueObject(valueA) &&\n      isValueObject(valueB) &&\n      valueA.equals(valueB)\n    );\n  }\n\n  var imul =\n    typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2\n      ? Math.imul\n      : function imul(a, b) {\n          a |= 0; // int\n          b |= 0; // int\n          var c = a & 0xffff;\n          var d = b & 0xffff;\n          // Shift by 0 fixes the sign on the high part.\n          return (c * d + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0)) | 0; // int\n        };\n\n  // v8 has an optimization for storing 31-bit signed numbers.\n  // Values which have either 00 or 11 as the high order bits qualify.\n  // This function drops the highest order bit in a signed number, maintaining\n  // the sign bit.\n  function smi(i32) {\n    return ((i32 >>> 1) & 0x40000000) | (i32 & 0xbfffffff);\n  }\n\n  var defaultValueOf = Object.prototype.valueOf;\n\n  function hash(o) {\n    if (o == null) {\n      return hashNullish(o);\n    }\n\n    if (typeof o.hashCode === 'function') {\n      // Drop any high bits from accidentally long hash codes.\n      return smi(o.hashCode(o));\n    }\n\n    var v = valueOf(o);\n\n    if (v == null) {\n      return hashNullish(v);\n    }\n\n    switch (typeof v) {\n      case 'boolean':\n        // The hash values for built-in constants are a 1 value for each 5-byte\n        // shift region expect for the first, which encodes the value. This\n        // reduces the odds of a hash collision for these common values.\n        return v ? 0x42108421 : 0x42108420;\n      case 'number':\n        return hashNumber(v);\n      case 'string':\n        return v.length > STRING_HASH_CACHE_MIN_STRLEN\n          ? cachedHashString(v)\n          : hashString(v);\n      case 'object':\n      case 'function':\n        return hashJSObj(v);\n      case 'symbol':\n        return hashSymbol(v);\n      default:\n        if (typeof v.toString === 'function') {\n          return hashString(v.toString());\n        }\n        throw new Error('Value type ' + typeof v + ' cannot be hashed.');\n    }\n  }\n\n  function hashNullish(nullish) {\n    return nullish === null ? 0x42108422 : /* undefined */ 0x42108423;\n  }\n\n  // Compress arbitrarily large numbers into smi hashes.\n  function hashNumber(n) {\n    if (n !== n || n === Infinity) {\n      return 0;\n    }\n    var hash = n | 0;\n    if (hash !== n) {\n      hash ^= n * 0xffffffff;\n    }\n    while (n > 0xffffffff) {\n      n /= 0xffffffff;\n      hash ^= n;\n    }\n    return smi(hash);\n  }\n\n  function cachedHashString(string) {\n    var hashed = stringHashCache[string];\n    if (hashed === undefined) {\n      hashed = hashString(string);\n      if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {\n        STRING_HASH_CACHE_SIZE = 0;\n        stringHashCache = {};\n      }\n      STRING_HASH_CACHE_SIZE++;\n      stringHashCache[string] = hashed;\n    }\n    return hashed;\n  }\n\n  // http://jsperf.com/hashing-strings\n  function hashString(string) {\n    // This is the hash from JVM\n    // The hash code for a string is computed as\n    // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],\n    // where s[i] is the ith character of the string and n is the length of\n    // the string. We \"mod\" the result to make it between 0 (inclusive) and 2^31\n    // (exclusive) by dropping high bits.\n    var hashed = 0;\n    for (var ii = 0; ii < string.length; ii++) {\n      hashed = (31 * hashed + string.charCodeAt(ii)) | 0;\n    }\n    return smi(hashed);\n  }\n\n  function hashSymbol(sym) {\n    var hashed = symbolMap[sym];\n    if (hashed !== undefined) {\n      return hashed;\n    }\n\n    hashed = nextHash();\n\n    symbolMap[sym] = hashed;\n\n    return hashed;\n  }\n\n  function hashJSObj(obj) {\n    var hashed;\n    if (usingWeakMap) {\n      hashed = weakMap.get(obj);\n      if (hashed !== undefined) {\n        return hashed;\n      }\n    }\n\n    hashed = obj[UID_HASH_KEY];\n    if (hashed !== undefined) {\n      return hashed;\n    }\n\n    if (!canDefineProperty) {\n      hashed = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];\n      if (hashed !== undefined) {\n        return hashed;\n      }\n\n      hashed = getIENodeHash(obj);\n      if (hashed !== undefined) {\n        return hashed;\n      }\n    }\n\n    hashed = nextHash();\n\n    if (usingWeakMap) {\n      weakMap.set(obj, hashed);\n    } else if (isExtensible !== undefined && isExtensible(obj) === false) {\n      throw new Error('Non-extensible objects are not allowed as keys.');\n    } else if (canDefineProperty) {\n      Object.defineProperty(obj, UID_HASH_KEY, {\n        enumerable: false,\n        configurable: false,\n        writable: false,\n        value: hashed,\n      });\n    } else if (\n      obj.propertyIsEnumerable !== undefined &&\n      obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable\n    ) {\n      // Since we can't define a non-enumerable property on the object\n      // we'll hijack one of the less-used non-enumerable properties to\n      // save our hash on it. Since this is a function it will not show up in\n      // `JSON.stringify` which is what we want.\n      obj.propertyIsEnumerable = function () {\n        return this.constructor.prototype.propertyIsEnumerable.apply(\n          this,\n          arguments\n        );\n      };\n      obj.propertyIsEnumerable[UID_HASH_KEY] = hashed;\n    } else if (obj.nodeType !== undefined) {\n      // At this point we couldn't get the IE `uniqueID` to use as a hash\n      // and we couldn't use a non-enumerable property to exploit the\n      // dontEnum bug so we simply add the `UID_HASH_KEY` on the node\n      // itself.\n      obj[UID_HASH_KEY] = hashed;\n    } else {\n      throw new Error('Unable to set a non-enumerable property on object.');\n    }\n\n    return hashed;\n  }\n\n  // Get references to ES5 object methods.\n  var isExtensible = Object.isExtensible;\n\n  // True if Object.defineProperty works as expected. IE8 fails this test.\n  var canDefineProperty = (function () {\n    try {\n      Object.defineProperty({}, '@', {});\n      return true;\n    } catch (e) {\n      return false;\n    }\n  })();\n\n  // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it\n  // and avoid memory leaks from the IE cloneNode bug.\n  function getIENodeHash(node) {\n    if (node && node.nodeType > 0) {\n      switch (node.nodeType) {\n        case 1: // Element\n          return node.uniqueID;\n        case 9: // Document\n          return node.documentElement && node.documentElement.uniqueID;\n      }\n    }\n  }\n\n  function valueOf(obj) {\n    return obj.valueOf !== defaultValueOf && typeof obj.valueOf === 'function'\n      ? obj.valueOf(obj)\n      : obj;\n  }\n\n  function nextHash() {\n    var nextHash = ++_objHashUID;\n    if (_objHashUID & 0x40000000) {\n      _objHashUID = 0;\n    }\n    return nextHash;\n  }\n\n  // If possible, use a WeakMap.\n  var usingWeakMap = typeof WeakMap === 'function';\n  var weakMap;\n  if (usingWeakMap) {\n    weakMap = new WeakMap();\n  }\n\n  var symbolMap = Object.create(null);\n\n  var _objHashUID = 0;\n\n  var UID_HASH_KEY = '__immutablehash__';\n  if (typeof Symbol === 'function') {\n    UID_HASH_KEY = Symbol(UID_HASH_KEY);\n  }\n\n  var STRING_HASH_CACHE_MIN_STRLEN = 16;\n  var STRING_HASH_CACHE_MAX_SIZE = 255;\n  var STRING_HASH_CACHE_SIZE = 0;\n  var stringHashCache = {};\n\n  var ToKeyedSequence = /*@__PURE__*/(function (KeyedSeq) {\n    function ToKeyedSequence(indexed, useKeys) {\n      this._iter = indexed;\n      this._useKeys = useKeys;\n      this.size = indexed.size;\n    }\n\n    if ( KeyedSeq ) ToKeyedSequence.__proto__ = KeyedSeq;\n    ToKeyedSequence.prototype = Object.create( KeyedSeq && KeyedSeq.prototype );\n    ToKeyedSequence.prototype.constructor = ToKeyedSequence;\n\n    ToKeyedSequence.prototype.get = function get (key, notSetValue) {\n      return this._iter.get(key, notSetValue);\n    };\n\n    ToKeyedSequence.prototype.has = function has (key) {\n      return this._iter.has(key);\n    };\n\n    ToKeyedSequence.prototype.valueSeq = function valueSeq () {\n      return this._iter.valueSeq();\n    };\n\n    ToKeyedSequence.prototype.reverse = function reverse () {\n      var this$1$1 = this;\n\n      var reversedSequence = reverseFactory(this, true);\n      if (!this._useKeys) {\n        reversedSequence.valueSeq = function () { return this$1$1._iter.toSeq().reverse(); };\n      }\n      return reversedSequence;\n    };\n\n    ToKeyedSequence.prototype.map = function map (mapper, context) {\n      var this$1$1 = this;\n\n      var mappedSequence = mapFactory(this, mapper, context);\n      if (!this._useKeys) {\n        mappedSequence.valueSeq = function () { return this$1$1._iter.toSeq().map(mapper, context); };\n      }\n      return mappedSequence;\n    };\n\n    ToKeyedSequence.prototype.__iterate = function __iterate (fn, reverse) {\n      var this$1$1 = this;\n\n      return this._iter.__iterate(function (v, k) { return fn(v, k, this$1$1); }, reverse);\n    };\n\n    ToKeyedSequence.prototype.__iterator = function __iterator (type, reverse) {\n      return this._iter.__iterator(type, reverse);\n    };\n\n    return ToKeyedSequence;\n  }(KeyedSeq));\n  ToKeyedSequence.prototype[IS_ORDERED_SYMBOL] = true;\n\n  var ToIndexedSequence = /*@__PURE__*/(function (IndexedSeq) {\n    function ToIndexedSequence(iter) {\n      this._iter = iter;\n      this.size = iter.size;\n    }\n\n    if ( IndexedSeq ) ToIndexedSequence.__proto__ = IndexedSeq;\n    ToIndexedSequence.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );\n    ToIndexedSequence.prototype.constructor = ToIndexedSequence;\n\n    ToIndexedSequence.prototype.includes = function includes (value) {\n      return this._iter.includes(value);\n    };\n\n    ToIndexedSequence.prototype.__iterate = function __iterate (fn, reverse) {\n      var this$1$1 = this;\n\n      var i = 0;\n      reverse && ensureSize(this);\n      return this._iter.__iterate(\n        function (v) { return fn(v, reverse ? this$1$1.size - ++i : i++, this$1$1); },\n        reverse\n      );\n    };\n\n    ToIndexedSequence.prototype.__iterator = function __iterator (type, reverse) {\n      var this$1$1 = this;\n\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      var i = 0;\n      reverse && ensureSize(this);\n      return new Iterator(function () {\n        var step = iterator.next();\n        return step.done\n          ? step\n          : iteratorValue(\n              type,\n              reverse ? this$1$1.size - ++i : i++,\n              step.value,\n              step\n            );\n      });\n    };\n\n    return ToIndexedSequence;\n  }(IndexedSeq));\n\n  var ToSetSequence = /*@__PURE__*/(function (SetSeq) {\n    function ToSetSequence(iter) {\n      this._iter = iter;\n      this.size = iter.size;\n    }\n\n    if ( SetSeq ) ToSetSequence.__proto__ = SetSeq;\n    ToSetSequence.prototype = Object.create( SetSeq && SetSeq.prototype );\n    ToSetSequence.prototype.constructor = ToSetSequence;\n\n    ToSetSequence.prototype.has = function has (key) {\n      return this._iter.includes(key);\n    };\n\n    ToSetSequence.prototype.__iterate = function __iterate (fn, reverse) {\n      var this$1$1 = this;\n\n      return this._iter.__iterate(function (v) { return fn(v, v, this$1$1); }, reverse);\n    };\n\n    ToSetSequence.prototype.__iterator = function __iterator (type, reverse) {\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      return new Iterator(function () {\n        var step = iterator.next();\n        return step.done\n          ? step\n          : iteratorValue(type, step.value, step.value, step);\n      });\n    };\n\n    return ToSetSequence;\n  }(SetSeq));\n\n  var FromEntriesSequence = /*@__PURE__*/(function (KeyedSeq) {\n    function FromEntriesSequence(entries) {\n      this._iter = entries;\n      this.size = entries.size;\n    }\n\n    if ( KeyedSeq ) FromEntriesSequence.__proto__ = KeyedSeq;\n    FromEntriesSequence.prototype = Object.create( KeyedSeq && KeyedSeq.prototype );\n    FromEntriesSequence.prototype.constructor = FromEntriesSequence;\n\n    FromEntriesSequence.prototype.entrySeq = function entrySeq () {\n      return this._iter.toSeq();\n    };\n\n    FromEntriesSequence.prototype.__iterate = function __iterate (fn, reverse) {\n      var this$1$1 = this;\n\n      return this._iter.__iterate(function (entry) {\n        // Check if entry exists first so array access doesn't throw for holes\n        // in the parent iteration.\n        if (entry) {\n          validateEntry(entry);\n          var indexedCollection = isCollection(entry);\n          return fn(\n            indexedCollection ? entry.get(1) : entry[1],\n            indexedCollection ? entry.get(0) : entry[0],\n            this$1$1\n          );\n        }\n      }, reverse);\n    };\n\n    FromEntriesSequence.prototype.__iterator = function __iterator (type, reverse) {\n      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);\n      return new Iterator(function () {\n        while (true) {\n          var step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n          var entry = step.value;\n          // Check if entry exists first so array access doesn't throw for holes\n          // in the parent iteration.\n          if (entry) {\n            validateEntry(entry);\n            var indexedCollection = isCollection(entry);\n            return iteratorValue(\n              type,\n              indexedCollection ? entry.get(0) : entry[0],\n              indexedCollection ? entry.get(1) : entry[1],\n              step\n            );\n          }\n        }\n      });\n    };\n\n    return FromEntriesSequence;\n  }(KeyedSeq));\n\n  ToIndexedSequence.prototype.cacheResult =\n    ToKeyedSequence.prototype.cacheResult =\n    ToSetSequence.prototype.cacheResult =\n    FromEntriesSequence.prototype.cacheResult =\n      cacheResultThrough;\n\n  function flipFactory(collection) {\n    var flipSequence = makeSequence(collection);\n    flipSequence._iter = collection;\n    flipSequence.size = collection.size;\n    flipSequence.flip = function () { return collection; };\n    flipSequence.reverse = function () {\n      var reversedSequence = collection.reverse.apply(this); // super.reverse()\n      reversedSequence.flip = function () { return collection.reverse(); };\n      return reversedSequence;\n    };\n    flipSequence.has = function (key) { return collection.includes(key); };\n    flipSequence.includes = function (key) { return collection.has(key); };\n    flipSequence.cacheResult = cacheResultThrough;\n    flipSequence.__iterateUncached = function (fn, reverse) {\n      var this$1$1 = this;\n\n      return collection.__iterate(function (v, k) { return fn(k, v, this$1$1) !== false; }, reverse);\n    };\n    flipSequence.__iteratorUncached = function (type, reverse) {\n      if (type === ITERATE_ENTRIES) {\n        var iterator = collection.__iterator(type, reverse);\n        return new Iterator(function () {\n          var step = iterator.next();\n          if (!step.done) {\n            var k = step.value[0];\n            step.value[0] = step.value[1];\n            step.value[1] = k;\n          }\n          return step;\n        });\n      }\n      return collection.__iterator(\n        type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES,\n        reverse\n      );\n    };\n    return flipSequence;\n  }\n\n  function mapFactory(collection, mapper, context) {\n    var mappedSequence = makeSequence(collection);\n    mappedSequence.size = collection.size;\n    mappedSequence.has = function (key) { return collection.has(key); };\n    mappedSequence.get = function (key, notSetValue) {\n      var v = collection.get(key, NOT_SET);\n      return v === NOT_SET\n        ? notSetValue\n        : mapper.call(context, v, key, collection);\n    };\n    mappedSequence.__iterateUncached = function (fn, reverse) {\n      var this$1$1 = this;\n\n      return collection.__iterate(\n        function (v, k, c) { return fn(mapper.call(context, v, k, c), k, this$1$1) !== false; },\n        reverse\n      );\n    };\n    mappedSequence.__iteratorUncached = function (type, reverse) {\n      var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);\n      return new Iterator(function () {\n        var step = iterator.next();\n        if (step.done) {\n          return step;\n        }\n        var entry = step.value;\n        var key = entry[0];\n        return iteratorValue(\n          type,\n          key,\n          mapper.call(context, entry[1], key, collection),\n          step\n        );\n      });\n    };\n    return mappedSequence;\n  }\n\n  function reverseFactory(collection, useKeys) {\n    var this$1$1 = this;\n\n    var reversedSequence = makeSequence(collection);\n    reversedSequence._iter = collection;\n    reversedSequence.size = collection.size;\n    reversedSequence.reverse = function () { return collection; };\n    if (collection.flip) {\n      reversedSequence.flip = function () {\n        var flipSequence = flipFactory(collection);\n        flipSequence.reverse = function () { return collection.flip(); };\n        return flipSequence;\n      };\n    }\n    reversedSequence.get = function (key, notSetValue) { return collection.get(useKeys ? key : -1 - key, notSetValue); };\n    reversedSequence.has = function (key) { return collection.has(useKeys ? key : -1 - key); };\n    reversedSequence.includes = function (value) { return collection.includes(value); };\n    reversedSequence.cacheResult = cacheResultThrough;\n    reversedSequence.__iterate = function (fn, reverse) {\n      var this$1$1 = this;\n\n      var i = 0;\n      reverse && ensureSize(collection);\n      return collection.__iterate(\n        function (v, k) { return fn(v, useKeys ? k : reverse ? this$1$1.size - ++i : i++, this$1$1); },\n        !reverse\n      );\n    };\n    reversedSequence.__iterator = function (type, reverse) {\n      var i = 0;\n      reverse && ensureSize(collection);\n      var iterator = collection.__iterator(ITERATE_ENTRIES, !reverse);\n      return new Iterator(function () {\n        var step = iterator.next();\n        if (step.done) {\n          return step;\n        }\n        var entry = step.value;\n        return iteratorValue(\n          type,\n          useKeys ? entry[0] : reverse ? this$1$1.size - ++i : i++,\n          entry[1],\n          step\n        );\n      });\n    };\n    return reversedSequence;\n  }\n\n  function filterFactory(collection, predicate, context, useKeys) {\n    var filterSequence = makeSequence(collection);\n    if (useKeys) {\n      filterSequence.has = function (key) {\n        var v = collection.get(key, NOT_SET);\n        return v !== NOT_SET && !!predicate.call(context, v, key, collection);\n      };\n      filterSequence.get = function (key, notSetValue) {\n        var v = collection.get(key, NOT_SET);\n        return v !== NOT_SET && predicate.call(context, v, key, collection)\n          ? v\n          : notSetValue;\n      };\n    }\n    filterSequence.__iterateUncached = function (fn, reverse) {\n      var this$1$1 = this;\n\n      var iterations = 0;\n      collection.__iterate(function (v, k, c) {\n        if (predicate.call(context, v, k, c)) {\n          iterations++;\n          return fn(v, useKeys ? k : iterations - 1, this$1$1);\n        }\n      }, reverse);\n      return iterations;\n    };\n    filterSequence.__iteratorUncached = function (type, reverse) {\n      var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);\n      var iterations = 0;\n      return new Iterator(function () {\n        while (true) {\n          var step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n          var entry = step.value;\n          var key = entry[0];\n          var value = entry[1];\n          if (predicate.call(context, value, key, collection)) {\n            return iteratorValue(type, useKeys ? key : iterations++, value, step);\n          }\n        }\n      });\n    };\n    return filterSequence;\n  }\n\n  function countByFactory(collection, grouper, context) {\n    var groups = Map().asMutable();\n    collection.__iterate(function (v, k) {\n      groups.update(grouper.call(context, v, k, collection), 0, function (a) { return a + 1; });\n    });\n    return groups.asImmutable();\n  }\n\n  function groupByFactory(collection, grouper, context) {\n    var isKeyedIter = isKeyed(collection);\n    var groups = (isOrdered(collection) ? OrderedMap() : Map()).asMutable();\n    collection.__iterate(function (v, k) {\n      groups.update(\n        grouper.call(context, v, k, collection),\n        function (a) { return ((a = a || []), a.push(isKeyedIter ? [k, v] : v), a); }\n      );\n    });\n    var coerce = collectionClass(collection);\n    return groups.map(function (arr) { return reify(collection, coerce(arr)); }).asImmutable();\n  }\n\n  function sliceFactory(collection, begin, end, useKeys) {\n    var originalSize = collection.size;\n\n    if (wholeSlice(begin, end, originalSize)) {\n      return collection;\n    }\n\n    var resolvedBegin = resolveBegin(begin, originalSize);\n    var resolvedEnd = resolveEnd(end, originalSize);\n\n    // begin or end will be NaN if they were provided as negative numbers and\n    // this collection's size is unknown. In that case, cache first so there is\n    // a known size and these do not resolve to NaN.\n    if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) {\n      return sliceFactory(collection.toSeq().cacheResult(), begin, end, useKeys);\n    }\n\n    // Note: resolvedEnd is undefined when the original sequence's length is\n    // unknown and this slice did not supply an end and should contain all\n    // elements after resolvedBegin.\n    // In that case, resolvedSize will be NaN and sliceSize will remain undefined.\n    var resolvedSize = resolvedEnd - resolvedBegin;\n    var sliceSize;\n    if (resolvedSize === resolvedSize) {\n      sliceSize = resolvedSize < 0 ? 0 : resolvedSize;\n    }\n\n    var sliceSeq = makeSequence(collection);\n\n    // If collection.size is undefined, the size of the realized sliceSeq is\n    // unknown at this point unless the number of items to slice is 0\n    sliceSeq.size =\n      sliceSize === 0 ? sliceSize : (collection.size && sliceSize) || undefined;\n\n    if (!useKeys && isSeq(collection) && sliceSize >= 0) {\n      sliceSeq.get = function (index, notSetValue) {\n        index = wrapIndex(this, index);\n        return index >= 0 && index < sliceSize\n          ? collection.get(index + resolvedBegin, notSetValue)\n          : notSetValue;\n      };\n    }\n\n    sliceSeq.__iterateUncached = function (fn, reverse) {\n      var this$1$1 = this;\n\n      if (sliceSize === 0) {\n        return 0;\n      }\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var skipped = 0;\n      var isSkipping = true;\n      var iterations = 0;\n      collection.__iterate(function (v, k) {\n        if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {\n          iterations++;\n          return (\n            fn(v, useKeys ? k : iterations - 1, this$1$1) !== false &&\n            iterations !== sliceSize\n          );\n        }\n      });\n      return iterations;\n    };\n\n    sliceSeq.__iteratorUncached = function (type, reverse) {\n      if (sliceSize !== 0 && reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      // Don't bother instantiating parent iterator if taking 0.\n      if (sliceSize === 0) {\n        return new Iterator(iteratorDone);\n      }\n      var iterator = collection.__iterator(type, reverse);\n      var skipped = 0;\n      var iterations = 0;\n      return new Iterator(function () {\n        while (skipped++ < resolvedBegin) {\n          iterator.next();\n        }\n        if (++iterations > sliceSize) {\n          return iteratorDone();\n        }\n        var step = iterator.next();\n        if (useKeys || type === ITERATE_VALUES || step.done) {\n          return step;\n        }\n        if (type === ITERATE_KEYS) {\n          return iteratorValue(type, iterations - 1, undefined, step);\n        }\n        return iteratorValue(type, iterations - 1, step.value[1], step);\n      });\n    };\n\n    return sliceSeq;\n  }\n\n  function takeWhileFactory(collection, predicate, context) {\n    var takeSequence = makeSequence(collection);\n    takeSequence.__iterateUncached = function (fn, reverse) {\n      var this$1$1 = this;\n\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var iterations = 0;\n      collection.__iterate(\n        function (v, k, c) { return predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$1$1); }\n      );\n      return iterations;\n    };\n    takeSequence.__iteratorUncached = function (type, reverse) {\n      var this$1$1 = this;\n\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);\n      var iterating = true;\n      return new Iterator(function () {\n        if (!iterating) {\n          return iteratorDone();\n        }\n        var step = iterator.next();\n        if (step.done) {\n          return step;\n        }\n        var entry = step.value;\n        var k = entry[0];\n        var v = entry[1];\n        if (!predicate.call(context, v, k, this$1$1)) {\n          iterating = false;\n          return iteratorDone();\n        }\n        return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step);\n      });\n    };\n    return takeSequence;\n  }\n\n  function skipWhileFactory(collection, predicate, context, useKeys) {\n    var skipSequence = makeSequence(collection);\n    skipSequence.__iterateUncached = function (fn, reverse) {\n      var this$1$1 = this;\n\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var isSkipping = true;\n      var iterations = 0;\n      collection.__iterate(function (v, k, c) {\n        if (!(isSkipping && (isSkipping = predicate.call(context, v, k, c)))) {\n          iterations++;\n          return fn(v, useKeys ? k : iterations - 1, this$1$1);\n        }\n      });\n      return iterations;\n    };\n    skipSequence.__iteratorUncached = function (type, reverse) {\n      var this$1$1 = this;\n\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = collection.__iterator(ITERATE_ENTRIES, reverse);\n      var skipping = true;\n      var iterations = 0;\n      return new Iterator(function () {\n        var step;\n        var k;\n        var v;\n        do {\n          step = iterator.next();\n          if (step.done) {\n            if (useKeys || type === ITERATE_VALUES) {\n              return step;\n            }\n            if (type === ITERATE_KEYS) {\n              return iteratorValue(type, iterations++, undefined, step);\n            }\n            return iteratorValue(type, iterations++, step.value[1], step);\n          }\n          var entry = step.value;\n          k = entry[0];\n          v = entry[1];\n          skipping && (skipping = predicate.call(context, v, k, this$1$1));\n        } while (skipping);\n        return type === ITERATE_ENTRIES ? step : iteratorValue(type, k, v, step);\n      });\n    };\n    return skipSequence;\n  }\n\n  function concatFactory(collection, values) {\n    var isKeyedCollection = isKeyed(collection);\n    var iters = [collection]\n      .concat(values)\n      .map(function (v) {\n        if (!isCollection(v)) {\n          v = isKeyedCollection\n            ? keyedSeqFromValue(v)\n            : indexedSeqFromValue(Array.isArray(v) ? v : [v]);\n        } else if (isKeyedCollection) {\n          v = KeyedCollection(v);\n        }\n        return v;\n      })\n      .filter(function (v) { return v.size !== 0; });\n\n    if (iters.length === 0) {\n      return collection;\n    }\n\n    if (iters.length === 1) {\n      var singleton = iters[0];\n      if (\n        singleton === collection ||\n        (isKeyedCollection && isKeyed(singleton)) ||\n        (isIndexed(collection) && isIndexed(singleton))\n      ) {\n        return singleton;\n      }\n    }\n\n    var concatSeq = new ArraySeq(iters);\n    if (isKeyedCollection) {\n      concatSeq = concatSeq.toKeyedSeq();\n    } else if (!isIndexed(collection)) {\n      concatSeq = concatSeq.toSetSeq();\n    }\n    concatSeq = concatSeq.flatten(true);\n    concatSeq.size = iters.reduce(function (sum, seq) {\n      if (sum !== undefined) {\n        var size = seq.size;\n        if (size !== undefined) {\n          return sum + size;\n        }\n      }\n    }, 0);\n    return concatSeq;\n  }\n\n  function flattenFactory(collection, depth, useKeys) {\n    var flatSequence = makeSequence(collection);\n    flatSequence.__iterateUncached = function (fn, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterate(fn, reverse);\n      }\n      var iterations = 0;\n      var stopped = false;\n      function flatDeep(iter, currentDepth) {\n        iter.__iterate(function (v, k) {\n          if ((!depth || currentDepth < depth) && isCollection(v)) {\n            flatDeep(v, currentDepth + 1);\n          } else {\n            iterations++;\n            if (fn(v, useKeys ? k : iterations - 1, flatSequence) === false) {\n              stopped = true;\n            }\n          }\n          return !stopped;\n        }, reverse);\n      }\n      flatDeep(collection, 0);\n      return iterations;\n    };\n    flatSequence.__iteratorUncached = function (type, reverse) {\n      if (reverse) {\n        return this.cacheResult().__iterator(type, reverse);\n      }\n      var iterator = collection.__iterator(type, reverse);\n      var stack = [];\n      var iterations = 0;\n      return new Iterator(function () {\n        while (iterator) {\n          var step = iterator.next();\n          if (step.done !== false) {\n            iterator = stack.pop();\n            continue;\n          }\n          var v = step.value;\n          if (type === ITERATE_ENTRIES) {\n            v = v[1];\n          }\n          if ((!depth || stack.length < depth) && isCollection(v)) {\n            stack.push(iterator);\n            iterator = v.__iterator(type, reverse);\n          } else {\n            return useKeys ? step : iteratorValue(type, iterations++, v, step);\n          }\n        }\n        return iteratorDone();\n      });\n    };\n    return flatSequence;\n  }\n\n  function flatMapFactory(collection, mapper, context) {\n    var coerce = collectionClass(collection);\n    return collection\n      .toSeq()\n      .map(function (v, k) { return coerce(mapper.call(context, v, k, collection)); })\n      .flatten(true);\n  }\n\n  function interposeFactory(collection, separator) {\n    var interposedSequence = makeSequence(collection);\n    interposedSequence.size = collection.size && collection.size * 2 - 1;\n    interposedSequence.__iterateUncached = function (fn, reverse) {\n      var this$1$1 = this;\n\n      var iterations = 0;\n      collection.__iterate(\n        function (v) { return (!iterations || fn(separator, iterations++, this$1$1) !== false) &&\n          fn(v, iterations++, this$1$1) !== false; },\n        reverse\n      );\n      return iterations;\n    };\n    interposedSequence.__iteratorUncached = function (type, reverse) {\n      var iterator = collection.__iterator(ITERATE_VALUES, reverse);\n      var iterations = 0;\n      var step;\n      return new Iterator(function () {\n        if (!step || iterations % 2) {\n          step = iterator.next();\n          if (step.done) {\n            return step;\n          }\n        }\n        return iterations % 2\n          ? iteratorValue(type, iterations++, separator)\n          : iteratorValue(type, iterations++, step.value, step);\n      });\n    };\n    return interposedSequence;\n  }\n\n  function sortFactory(collection, comparator, mapper) {\n    if (!comparator) {\n      comparator = defaultComparator;\n    }\n    var isKeyedCollection = isKeyed(collection);\n    var index = 0;\n    var entries = collection\n      .toSeq()\n      .map(function (v, k) { return [k, v, index++, mapper ? mapper(v, k, collection) : v]; })\n      .valueSeq()\n      .toArray();\n    entries\n      .sort(function (a, b) { return comparator(a[3], b[3]) || a[2] - b[2]; })\n      .forEach(\n        isKeyedCollection\n          ? function (v, i) {\n              entries[i].length = 2;\n            }\n          : function (v, i) {\n              entries[i] = v[1];\n            }\n      );\n    return isKeyedCollection\n      ? KeyedSeq(entries)\n      : isIndexed(collection)\n      ? IndexedSeq(entries)\n      : SetSeq(entries);\n  }\n\n  function maxFactory(collection, comparator, mapper) {\n    if (!comparator) {\n      comparator = defaultComparator;\n    }\n    if (mapper) {\n      var entry = collection\n        .toSeq()\n        .map(function (v, k) { return [v, mapper(v, k, collection)]; })\n        .reduce(function (a, b) { return (maxCompare(comparator, a[1], b[1]) ? b : a); });\n      return entry && entry[0];\n    }\n    return collection.reduce(function (a, b) { return (maxCompare(comparator, a, b) ? b : a); });\n  }\n\n  function maxCompare(comparator, a, b) {\n    var comp = comparator(b, a);\n    // b is considered the new max if the comparator declares them equal, but\n    // they are not equal and b is in fact a nullish value.\n    return (\n      (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) ||\n      comp > 0\n    );\n  }\n\n  function zipWithFactory(keyIter, zipper, iters, zipAll) {\n    var zipSequence = makeSequence(keyIter);\n    var sizes = new ArraySeq(iters).map(function (i) { return i.size; });\n    zipSequence.size = zipAll ? sizes.max() : sizes.min();\n    // Note: this a generic base implementation of __iterate in terms of\n    // __iterator which may be more generically useful in the future.\n    zipSequence.__iterate = function (fn, reverse) {\n      /* generic:\n      var iterator = this.__iterator(ITERATE_ENTRIES, reverse);\n      var step;\n      var iterations = 0;\n      while (!(step = iterator.next()).done) {\n        iterations++;\n        if (fn(step.value[1], step.value[0], this) === false) {\n          break;\n        }\n      }\n      return iterations;\n      */\n      // indexed:\n      var iterator = this.__iterator(ITERATE_VALUES, reverse);\n      var step;\n      var iterations = 0;\n      while (!(step = iterator.next()).done) {\n        if (fn(step.value, iterations++, this) === false) {\n          break;\n        }\n      }\n      return iterations;\n    };\n    zipSequence.__iteratorUncached = function (type, reverse) {\n      var iterators = iters.map(\n        function (i) { return ((i = Collection(i)), getIterator(reverse ? i.reverse() : i)); }\n      );\n      var iterations = 0;\n      var isDone = false;\n      return new Iterator(function () {\n        var steps;\n        if (!isDone) {\n          steps = iterators.map(function (i) { return i.next(); });\n          isDone = zipAll ? steps.every(function (s) { return s.done; }) : steps.some(function (s) { return s.done; });\n        }\n        if (isDone) {\n          return iteratorDone();\n        }\n        return iteratorValue(\n          type,\n          iterations++,\n          zipper.apply(\n            null,\n            steps.map(function (s) { return s.value; })\n          )\n        );\n      });\n    };\n    return zipSequence;\n  }\n\n  // #pragma Helper Functions\n\n  function reify(iter, seq) {\n    return iter === seq ? iter : isSeq(iter) ? seq : iter.constructor(seq);\n  }\n\n  function validateEntry(entry) {\n    if (entry !== Object(entry)) {\n      throw new TypeError('Expected [K, V] tuple: ' + entry);\n    }\n  }\n\n  function collectionClass(collection) {\n    return isKeyed(collection)\n      ? KeyedCollection\n      : isIndexed(collection)\n      ? IndexedCollection\n      : SetCollection;\n  }\n\n  function makeSequence(collection) {\n    return Object.create(\n      (isKeyed(collection)\n        ? KeyedSeq\n        : isIndexed(collection)\n        ? IndexedSeq\n        : SetSeq\n      ).prototype\n    );\n  }\n\n  function cacheResultThrough() {\n    if (this._iter.cacheResult) {\n      this._iter.cacheResult();\n      this.size = this._iter.size;\n      return this;\n    }\n    return Seq.prototype.cacheResult.call(this);\n  }\n\n  function defaultComparator(a, b) {\n    if (a === undefined && b === undefined) {\n      return 0;\n    }\n\n    if (a === undefined) {\n      return 1;\n    }\n\n    if (b === undefined) {\n      return -1;\n    }\n\n    return a > b ? 1 : a < b ? -1 : 0;\n  }\n\n  function arrCopy(arr, offset) {\n    offset = offset || 0;\n    var len = Math.max(0, arr.length - offset);\n    var newArr = new Array(len);\n    for (var ii = 0; ii < len; ii++) {\n      newArr[ii] = arr[ii + offset];\n    }\n    return newArr;\n  }\n\n  function invariant(condition, error) {\n    if (!condition) { throw new Error(error); }\n  }\n\n  function assertNotInfinite(size) {\n    invariant(\n      size !== Infinity,\n      'Cannot perform this action with an infinite size.'\n    );\n  }\n\n  function coerceKeyPath(keyPath) {\n    if (isArrayLike(keyPath) && typeof keyPath !== 'string') {\n      return keyPath;\n    }\n    if (isOrdered(keyPath)) {\n      return keyPath.toArray();\n    }\n    throw new TypeError(\n      'Invalid keyPath: expected Ordered Collection or Array: ' + keyPath\n    );\n  }\n\n  var toString = Object.prototype.toString;\n\n  function isPlainObject(value) {\n    // The base prototype's toString deals with Argument objects and native namespaces like Math\n    if (\n      !value ||\n      typeof value !== 'object' ||\n      toString.call(value) !== '[object Object]'\n    ) {\n      return false;\n    }\n\n    var proto = Object.getPrototypeOf(value);\n    if (proto === null) {\n      return true;\n    }\n\n    // Iteratively going up the prototype chain is needed for cross-realm environments (differing contexts, iframes, etc)\n    var parentProto = proto;\n    var nextProto = Object.getPrototypeOf(proto);\n    while (nextProto !== null) {\n      parentProto = nextProto;\n      nextProto = Object.getPrototypeOf(parentProto);\n    }\n    return parentProto === proto;\n  }\n\n  /**\n   * Returns true if the value is a potentially-persistent data structure, either\n   * provided by Immutable.js or a plain Array or Object.\n   */\n  function isDataStructure(value) {\n    return (\n      typeof value === 'object' &&\n      (isImmutable(value) || Array.isArray(value) || isPlainObject(value))\n    );\n  }\n\n  function quoteString(value) {\n    try {\n      return typeof value === 'string' ? JSON.stringify(value) : String(value);\n    } catch (_ignoreError) {\n      return JSON.stringify(value);\n    }\n  }\n\n  function has(collection, key) {\n    return isImmutable(collection)\n      ? collection.has(key)\n      : isDataStructure(collection) && hasOwnProperty.call(collection, key);\n  }\n\n  function get(collection, key, notSetValue) {\n    return isImmutable(collection)\n      ? collection.get(key, notSetValue)\n      : !has(collection, key)\n      ? notSetValue\n      : typeof collection.get === 'function'\n      ? collection.get(key)\n      : collection[key];\n  }\n\n  function shallowCopy(from) {\n    if (Array.isArray(from)) {\n      return arrCopy(from);\n    }\n    var to = {};\n    for (var key in from) {\n      if (hasOwnProperty.call(from, key)) {\n        to[key] = from[key];\n      }\n    }\n    return to;\n  }\n\n  function remove(collection, key) {\n    if (!isDataStructure(collection)) {\n      throw new TypeError(\n        'Cannot update non-data-structure value: ' + collection\n      );\n    }\n    if (isImmutable(collection)) {\n      if (!collection.remove) {\n        throw new TypeError(\n          'Cannot update immutable value without .remove() method: ' + collection\n        );\n      }\n      return collection.remove(key);\n    }\n    if (!hasOwnProperty.call(collection, key)) {\n      return collection;\n    }\n    var collectionCopy = shallowCopy(collection);\n    if (Array.isArray(collectionCopy)) {\n      collectionCopy.splice(key, 1);\n    } else {\n      delete collectionCopy[key];\n    }\n    return collectionCopy;\n  }\n\n  function set(collection, key, value) {\n    if (!isDataStructure(collection)) {\n      throw new TypeError(\n        'Cannot update non-data-structure value: ' + collection\n      );\n    }\n    if (isImmutable(collection)) {\n      if (!collection.set) {\n        throw new TypeError(\n          'Cannot update immutable value without .set() method: ' + collection\n        );\n      }\n      return collection.set(key, value);\n    }\n    if (hasOwnProperty.call(collection, key) && value === collection[key]) {\n      return collection;\n    }\n    var collectionCopy = shallowCopy(collection);\n    collectionCopy[key] = value;\n    return collectionCopy;\n  }\n\n  function updateIn$1(collection, keyPath, notSetValue, updater) {\n    if (!updater) {\n      updater = notSetValue;\n      notSetValue = undefined;\n    }\n    var updatedValue = updateInDeeply(\n      isImmutable(collection),\n      collection,\n      coerceKeyPath(keyPath),\n      0,\n      notSetValue,\n      updater\n    );\n    return updatedValue === NOT_SET ? notSetValue : updatedValue;\n  }\n\n  function updateInDeeply(\n    inImmutable,\n    existing,\n    keyPath,\n    i,\n    notSetValue,\n    updater\n  ) {\n    var wasNotSet = existing === NOT_SET;\n    if (i === keyPath.length) {\n      var existingValue = wasNotSet ? notSetValue : existing;\n      var newValue = updater(existingValue);\n      return newValue === existingValue ? existing : newValue;\n    }\n    if (!wasNotSet && !isDataStructure(existing)) {\n      throw new TypeError(\n        'Cannot update within non-data-structure value in path [' +\n          keyPath.slice(0, i).map(quoteString) +\n          ']: ' +\n          existing\n      );\n    }\n    var key = keyPath[i];\n    var nextExisting = wasNotSet ? NOT_SET : get(existing, key, NOT_SET);\n    var nextUpdated = updateInDeeply(\n      nextExisting === NOT_SET ? inImmutable : isImmutable(nextExisting),\n      nextExisting,\n      keyPath,\n      i + 1,\n      notSetValue,\n      updater\n    );\n    return nextUpdated === nextExisting\n      ? existing\n      : nextUpdated === NOT_SET\n      ? remove(existing, key)\n      : set(\n          wasNotSet ? (inImmutable ? emptyMap() : {}) : existing,\n          key,\n          nextUpdated\n        );\n  }\n\n  function setIn$1(collection, keyPath, value) {\n    return updateIn$1(collection, keyPath, NOT_SET, function () { return value; });\n  }\n\n  function setIn(keyPath, v) {\n    return setIn$1(this, keyPath, v);\n  }\n\n  function removeIn(collection, keyPath) {\n    return updateIn$1(collection, keyPath, function () { return NOT_SET; });\n  }\n\n  function deleteIn(keyPath) {\n    return removeIn(this, keyPath);\n  }\n\n  function update$1(collection, key, notSetValue, updater) {\n    return updateIn$1(collection, [key], notSetValue, updater);\n  }\n\n  function update(key, notSetValue, updater) {\n    return arguments.length === 1\n      ? key(this)\n      : update$1(this, key, notSetValue, updater);\n  }\n\n  function updateIn(keyPath, notSetValue, updater) {\n    return updateIn$1(this, keyPath, notSetValue, updater);\n  }\n\n  function merge$1() {\n    var iters = [], len = arguments.length;\n    while ( len-- ) iters[ len ] = arguments[ len ];\n\n    return mergeIntoKeyedWith(this, iters);\n  }\n\n  function mergeWith$1(merger) {\n    var iters = [], len = arguments.length - 1;\n    while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];\n\n    if (typeof merger !== 'function') {\n      throw new TypeError('Invalid merger function: ' + merger);\n    }\n    return mergeIntoKeyedWith(this, iters, merger);\n  }\n\n  function mergeIntoKeyedWith(collection, collections, merger) {\n    var iters = [];\n    for (var ii = 0; ii < collections.length; ii++) {\n      var collection$1 = KeyedCollection(collections[ii]);\n      if (collection$1.size !== 0) {\n        iters.push(collection$1);\n      }\n    }\n    if (iters.length === 0) {\n      return collection;\n    }\n    if (\n      collection.toSeq().size === 0 &&\n      !collection.__ownerID &&\n      iters.length === 1\n    ) {\n      return collection.constructor(iters[0]);\n    }\n    return collection.withMutations(function (collection) {\n      var mergeIntoCollection = merger\n        ? function (value, key) {\n            update$1(collection, key, NOT_SET, function (oldVal) { return oldVal === NOT_SET ? value : merger(oldVal, value, key); }\n            );\n          }\n        : function (value, key) {\n            collection.set(key, value);\n          };\n      for (var ii = 0; ii < iters.length; ii++) {\n        iters[ii].forEach(mergeIntoCollection);\n      }\n    });\n  }\n\n  function merge(collection) {\n    var sources = [], len = arguments.length - 1;\n    while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ];\n\n    return mergeWithSources(collection, sources);\n  }\n\n  function mergeWith(merger, collection) {\n    var sources = [], len = arguments.length - 2;\n    while ( len-- > 0 ) sources[ len ] = arguments[ len + 2 ];\n\n    return mergeWithSources(collection, sources, merger);\n  }\n\n  function mergeDeep$1(collection) {\n    var sources = [], len = arguments.length - 1;\n    while ( len-- > 0 ) sources[ len ] = arguments[ len + 1 ];\n\n    return mergeDeepWithSources(collection, sources);\n  }\n\n  function mergeDeepWith$1(merger, collection) {\n    var sources = [], len = arguments.length - 2;\n    while ( len-- > 0 ) sources[ len ] = arguments[ len + 2 ];\n\n    return mergeDeepWithSources(collection, sources, merger);\n  }\n\n  function mergeDeepWithSources(collection, sources, merger) {\n    return mergeWithSources(collection, sources, deepMergerWith(merger));\n  }\n\n  function mergeWithSources(collection, sources, merger) {\n    if (!isDataStructure(collection)) {\n      throw new TypeError(\n        'Cannot merge into non-data-structure value: ' + collection\n      );\n    }\n    if (isImmutable(collection)) {\n      return typeof merger === 'function' && collection.mergeWith\n        ? collection.mergeWith.apply(collection, [ merger ].concat( sources ))\n        : collection.merge\n        ? collection.merge.apply(collection, sources)\n        : collection.concat.apply(collection, sources);\n    }\n    var isArray = Array.isArray(collection);\n    var merged = collection;\n    var Collection = isArray ? IndexedCollection : KeyedCollection;\n    var mergeItem = isArray\n      ? function (value) {\n          // Copy on write\n          if (merged === collection) {\n            merged = shallowCopy(merged);\n          }\n          merged.push(value);\n        }\n      : function (value, key) {\n          var hasVal = hasOwnProperty.call(merged, key);\n          var nextVal =\n            hasVal && merger ? merger(merged[key], value, key) : value;\n          if (!hasVal || nextVal !== merged[key]) {\n            // Copy on write\n            if (merged === collection) {\n              merged = shallowCopy(merged);\n            }\n            merged[key] = nextVal;\n          }\n        };\n    for (var i = 0; i < sources.length; i++) {\n      Collection(sources[i]).forEach(mergeItem);\n    }\n    return merged;\n  }\n\n  function deepMergerWith(merger) {\n    function deepMerger(oldValue, newValue, key) {\n      return isDataStructure(oldValue) &&\n        isDataStructure(newValue) &&\n        areMergeable(oldValue, newValue)\n        ? mergeWithSources(oldValue, [newValue], deepMerger)\n        : merger\n        ? merger(oldValue, newValue, key)\n        : newValue;\n    }\n    return deepMerger;\n  }\n\n  /**\n   * It's unclear what the desired behavior is for merging two collections that\n   * fall into separate categories between keyed, indexed, or set-like, so we only\n   * consider them mergeable if they fall into the same category.\n   */\n  function areMergeable(oldDataStructure, newDataStructure) {\n    var oldSeq = Seq(oldDataStructure);\n    var newSeq = Seq(newDataStructure);\n    // This logic assumes that a sequence can only fall into one of the three\n    // categories mentioned above (since there's no `isSetLike()` method).\n    return (\n      isIndexed(oldSeq) === isIndexed(newSeq) &&\n      isKeyed(oldSeq) === isKeyed(newSeq)\n    );\n  }\n\n  function mergeDeep() {\n    var iters = [], len = arguments.length;\n    while ( len-- ) iters[ len ] = arguments[ len ];\n\n    return mergeDeepWithSources(this, iters);\n  }\n\n  function mergeDeepWith(merger) {\n    var iters = [], len = arguments.length - 1;\n    while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];\n\n    return mergeDeepWithSources(this, iters, merger);\n  }\n\n  function mergeIn(keyPath) {\n    var iters = [], len = arguments.length - 1;\n    while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];\n\n    return updateIn$1(this, keyPath, emptyMap(), function (m) { return mergeWithSources(m, iters); });\n  }\n\n  function mergeDeepIn(keyPath) {\n    var iters = [], len = arguments.length - 1;\n    while ( len-- > 0 ) iters[ len ] = arguments[ len + 1 ];\n\n    return updateIn$1(this, keyPath, emptyMap(), function (m) { return mergeDeepWithSources(m, iters); }\n    );\n  }\n\n  function withMutations(fn) {\n    var mutable = this.asMutable();\n    fn(mutable);\n    return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this;\n  }\n\n  function asMutable() {\n    return this.__ownerID ? this : this.__ensureOwner(new OwnerID());\n  }\n\n  function asImmutable() {\n    return this.__ensureOwner();\n  }\n\n  function wasAltered() {\n    return this.__altered;\n  }\n\n  var Map = /*@__PURE__*/(function (KeyedCollection) {\n    function Map(value) {\n      return value === undefined || value === null\n        ? emptyMap()\n        : isMap(value) && !isOrdered(value)\n        ? value\n        : emptyMap().withMutations(function (map) {\n            var iter = KeyedCollection(value);\n            assertNotInfinite(iter.size);\n            iter.forEach(function (v, k) { return map.set(k, v); });\n          });\n    }\n\n    if ( KeyedCollection ) Map.__proto__ = KeyedCollection;\n    Map.prototype = Object.create( KeyedCollection && KeyedCollection.prototype );\n    Map.prototype.constructor = Map;\n\n    Map.of = function of () {\n      var keyValues = [], len = arguments.length;\n      while ( len-- ) keyValues[ len ] = arguments[ len ];\n\n      return emptyMap().withMutations(function (map) {\n        for (var i = 0; i < keyValues.length; i += 2) {\n          if (i + 1 >= keyValues.length) {\n            throw new Error('Missing value for key: ' + keyValues[i]);\n          }\n          map.set(keyValues[i], keyValues[i + 1]);\n        }\n      });\n    };\n\n    Map.prototype.toString = function toString () {\n      return this.__toString('Map {', '}');\n    };\n\n    // @pragma Access\n\n    Map.prototype.get = function get (k, notSetValue) {\n      return this._root\n        ? this._root.get(0, undefined, k, notSetValue)\n        : notSetValue;\n    };\n\n    // @pragma Modification\n\n    Map.prototype.set = function set (k, v) {\n      return updateMap(this, k, v);\n    };\n\n    Map.prototype.remove = function remove (k) {\n      return updateMap(this, k, NOT_SET);\n    };\n\n    Map.prototype.deleteAll = function deleteAll (keys) {\n      var collection = Collection(keys);\n\n      if (collection.size === 0) {\n        return this;\n      }\n\n      return this.withMutations(function (map) {\n        collection.forEach(function (key) { return map.remove(key); });\n      });\n    };\n\n    Map.prototype.clear = function clear () {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._root = null;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyMap();\n    };\n\n    // @pragma Composition\n\n    Map.prototype.sort = function sort (comparator) {\n      // Late binding\n      return OrderedMap(sortFactory(this, comparator));\n    };\n\n    Map.prototype.sortBy = function sortBy (mapper, comparator) {\n      // Late binding\n      return OrderedMap(sortFactory(this, comparator, mapper));\n    };\n\n    Map.prototype.map = function map (mapper, context) {\n      var this$1$1 = this;\n\n      return this.withMutations(function (map) {\n        map.forEach(function (value, key) {\n          map.set(key, mapper.call(context, value, key, this$1$1));\n        });\n      });\n    };\n\n    // @pragma Mutability\n\n    Map.prototype.__iterator = function __iterator (type, reverse) {\n      return new MapIterator(this, type, reverse);\n    };\n\n    Map.prototype.__iterate = function __iterate (fn, reverse) {\n      var this$1$1 = this;\n\n      var iterations = 0;\n      this._root &&\n        this._root.iterate(function (entry) {\n          iterations++;\n          return fn(entry[1], entry[0], this$1$1);\n        }, reverse);\n      return iterations;\n    };\n\n    Map.prototype.__ensureOwner = function __ensureOwner (ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        if (this.size === 0) {\n          return emptyMap();\n        }\n        this.__ownerID = ownerID;\n        this.__altered = false;\n        return this;\n      }\n      return makeMap(this.size, this._root, ownerID, this.__hash);\n    };\n\n    return Map;\n  }(KeyedCollection));\n\n  Map.isMap = isMap;\n\n  var MapPrototype = Map.prototype;\n  MapPrototype[IS_MAP_SYMBOL] = true;\n  MapPrototype[DELETE] = MapPrototype.remove;\n  MapPrototype.removeAll = MapPrototype.deleteAll;\n  MapPrototype.setIn = setIn;\n  MapPrototype.removeIn = MapPrototype.deleteIn = deleteIn;\n  MapPrototype.update = update;\n  MapPrototype.updateIn = updateIn;\n  MapPrototype.merge = MapPrototype.concat = merge$1;\n  MapPrototype.mergeWith = mergeWith$1;\n  MapPrototype.mergeDeep = mergeDeep;\n  MapPrototype.mergeDeepWith = mergeDeepWith;\n  MapPrototype.mergeIn = mergeIn;\n  MapPrototype.mergeDeepIn = mergeDeepIn;\n  MapPrototype.withMutations = withMutations;\n  MapPrototype.wasAltered = wasAltered;\n  MapPrototype.asImmutable = asImmutable;\n  MapPrototype['@@transducer/init'] = MapPrototype.asMutable = asMutable;\n  MapPrototype['@@transducer/step'] = function (result, arr) {\n    return result.set(arr[0], arr[1]);\n  };\n  MapPrototype['@@transducer/result'] = function (obj) {\n    return obj.asImmutable();\n  };\n\n  // #pragma Trie Nodes\n\n  var ArrayMapNode = function ArrayMapNode(ownerID, entries) {\n    this.ownerID = ownerID;\n    this.entries = entries;\n  };\n\n  ArrayMapNode.prototype.get = function get (shift, keyHash, key, notSetValue) {\n    var entries = this.entries;\n    for (var ii = 0, len = entries.length; ii < len; ii++) {\n      if (is(key, entries[ii][0])) {\n        return entries[ii][1];\n      }\n    }\n    return notSetValue;\n  };\n\n  ArrayMapNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n    var removed = value === NOT_SET;\n\n    var entries = this.entries;\n    var idx = 0;\n    var len = entries.length;\n    for (; idx < len; idx++) {\n      if (is(key, entries[idx][0])) {\n        break;\n      }\n    }\n    var exists = idx < len;\n\n    if (exists ? entries[idx][1] === value : removed) {\n      return this;\n    }\n\n    SetRef(didAlter);\n    (removed || !exists) && SetRef(didChangeSize);\n\n    if (removed && entries.length === 1) {\n      return; // undefined\n    }\n\n    if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {\n      return createNodes(ownerID, entries, key, value);\n    }\n\n    var isEditable = ownerID && ownerID === this.ownerID;\n    var newEntries = isEditable ? entries : arrCopy(entries);\n\n    if (exists) {\n      if (removed) {\n        idx === len - 1\n          ? newEntries.pop()\n          : (newEntries[idx] = newEntries.pop());\n      } else {\n        newEntries[idx] = [key, value];\n      }\n    } else {\n      newEntries.push([key, value]);\n    }\n\n    if (isEditable) {\n      this.entries = newEntries;\n      return this;\n    }\n\n    return new ArrayMapNode(ownerID, newEntries);\n  };\n\n  var BitmapIndexedNode = function BitmapIndexedNode(ownerID, bitmap, nodes) {\n    this.ownerID = ownerID;\n    this.bitmap = bitmap;\n    this.nodes = nodes;\n  };\n\n  BitmapIndexedNode.prototype.get = function get (shift, keyHash, key, notSetValue) {\n    if (keyHash === undefined) {\n      keyHash = hash(key);\n    }\n    var bit = 1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK);\n    var bitmap = this.bitmap;\n    return (bitmap & bit) === 0\n      ? notSetValue\n      : this.nodes[popCount(bitmap & (bit - 1))].get(\n          shift + SHIFT,\n          keyHash,\n          key,\n          notSetValue\n        );\n  };\n\n  BitmapIndexedNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n    if (keyHash === undefined) {\n      keyHash = hash(key);\n    }\n    var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n    var bit = 1 << keyHashFrag;\n    var bitmap = this.bitmap;\n    var exists = (bitmap & bit) !== 0;\n\n    if (!exists && value === NOT_SET) {\n      return this;\n    }\n\n    var idx = popCount(bitmap & (bit - 1));\n    var nodes = this.nodes;\n    var node = exists ? nodes[idx] : undefined;\n    var newNode = updateNode(\n      node,\n      ownerID,\n      shift + SHIFT,\n      keyHash,\n      key,\n      value,\n      didChangeSize,\n      didAlter\n    );\n\n    if (newNode === node) {\n      return this;\n    }\n\n    if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {\n      return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);\n    }\n\n    if (\n      exists &&\n      !newNode &&\n      nodes.length === 2 &&\n      isLeafNode(nodes[idx ^ 1])\n    ) {\n      return nodes[idx ^ 1];\n    }\n\n    if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {\n      return newNode;\n    }\n\n    var isEditable = ownerID && ownerID === this.ownerID;\n    var newBitmap = exists ? (newNode ? bitmap : bitmap ^ bit) : bitmap | bit;\n    var newNodes = exists\n      ? newNode\n        ? setAt(nodes, idx, newNode, isEditable)\n        : spliceOut(nodes, idx, isEditable)\n      : spliceIn(nodes, idx, newNode, isEditable);\n\n    if (isEditable) {\n      this.bitmap = newBitmap;\n      this.nodes = newNodes;\n      return this;\n    }\n\n    return new BitmapIndexedNode(ownerID, newBitmap, newNodes);\n  };\n\n  var HashArrayMapNode = function HashArrayMapNode(ownerID, count, nodes) {\n    this.ownerID = ownerID;\n    this.count = count;\n    this.nodes = nodes;\n  };\n\n  HashArrayMapNode.prototype.get = function get (shift, keyHash, key, notSetValue) {\n    if (keyHash === undefined) {\n      keyHash = hash(key);\n    }\n    var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n    var node = this.nodes[idx];\n    return node\n      ? node.get(shift + SHIFT, keyHash, key, notSetValue)\n      : notSetValue;\n  };\n\n  HashArrayMapNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n    if (keyHash === undefined) {\n      keyHash = hash(key);\n    }\n    var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n    var removed = value === NOT_SET;\n    var nodes = this.nodes;\n    var node = nodes[idx];\n\n    if (removed && !node) {\n      return this;\n    }\n\n    var newNode = updateNode(\n      node,\n      ownerID,\n      shift + SHIFT,\n      keyHash,\n      key,\n      value,\n      didChangeSize,\n      didAlter\n    );\n    if (newNode === node) {\n      return this;\n    }\n\n    var newCount = this.count;\n    if (!node) {\n      newCount++;\n    } else if (!newNode) {\n      newCount--;\n      if (newCount < MIN_HASH_ARRAY_MAP_SIZE) {\n        return packNodes(ownerID, nodes, newCount, idx);\n      }\n    }\n\n    var isEditable = ownerID && ownerID === this.ownerID;\n    var newNodes = setAt(nodes, idx, newNode, isEditable);\n\n    if (isEditable) {\n      this.count = newCount;\n      this.nodes = newNodes;\n      return this;\n    }\n\n    return new HashArrayMapNode(ownerID, newCount, newNodes);\n  };\n\n  var HashCollisionNode = function HashCollisionNode(ownerID, keyHash, entries) {\n    this.ownerID = ownerID;\n    this.keyHash = keyHash;\n    this.entries = entries;\n  };\n\n  HashCollisionNode.prototype.get = function get (shift, keyHash, key, notSetValue) {\n    var entries = this.entries;\n    for (var ii = 0, len = entries.length; ii < len; ii++) {\n      if (is(key, entries[ii][0])) {\n        return entries[ii][1];\n      }\n    }\n    return notSetValue;\n  };\n\n  HashCollisionNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n    if (keyHash === undefined) {\n      keyHash = hash(key);\n    }\n\n    var removed = value === NOT_SET;\n\n    if (keyHash !== this.keyHash) {\n      if (removed) {\n        return this;\n      }\n      SetRef(didAlter);\n      SetRef(didChangeSize);\n      return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);\n    }\n\n    var entries = this.entries;\n    var idx = 0;\n    var len = entries.length;\n    for (; idx < len; idx++) {\n      if (is(key, entries[idx][0])) {\n        break;\n      }\n    }\n    var exists = idx < len;\n\n    if (exists ? entries[idx][1] === value : removed) {\n      return this;\n    }\n\n    SetRef(didAlter);\n    (removed || !exists) && SetRef(didChangeSize);\n\n    if (removed && len === 2) {\n      return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);\n    }\n\n    var isEditable = ownerID && ownerID === this.ownerID;\n    var newEntries = isEditable ? entries : arrCopy(entries);\n\n    if (exists) {\n      if (removed) {\n        idx === len - 1\n          ? newEntries.pop()\n          : (newEntries[idx] = newEntries.pop());\n      } else {\n        newEntries[idx] = [key, value];\n      }\n    } else {\n      newEntries.push([key, value]);\n    }\n\n    if (isEditable) {\n      this.entries = newEntries;\n      return this;\n    }\n\n    return new HashCollisionNode(ownerID, this.keyHash, newEntries);\n  };\n\n  var ValueNode = function ValueNode(ownerID, keyHash, entry) {\n    this.ownerID = ownerID;\n    this.keyHash = keyHash;\n    this.entry = entry;\n  };\n\n  ValueNode.prototype.get = function get (shift, keyHash, key, notSetValue) {\n    return is(key, this.entry[0]) ? this.entry[1] : notSetValue;\n  };\n\n  ValueNode.prototype.update = function update (ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {\n    var removed = value === NOT_SET;\n    var keyMatch = is(key, this.entry[0]);\n    if (keyMatch ? value === this.entry[1] : removed) {\n      return this;\n    }\n\n    SetRef(didAlter);\n\n    if (removed) {\n      SetRef(didChangeSize);\n      return; // undefined\n    }\n\n    if (keyMatch) {\n      if (ownerID && ownerID === this.ownerID) {\n        this.entry[1] = value;\n        return this;\n      }\n      return new ValueNode(ownerID, this.keyHash, [key, value]);\n    }\n\n    SetRef(didChangeSize);\n    return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);\n  };\n\n  // #pragma Iterators\n\n  ArrayMapNode.prototype.iterate = HashCollisionNode.prototype.iterate =\n    function (fn, reverse) {\n      var entries = this.entries;\n      for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {\n        if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {\n          return false;\n        }\n      }\n    };\n\n  BitmapIndexedNode.prototype.iterate = HashArrayMapNode.prototype.iterate =\n    function (fn, reverse) {\n      var nodes = this.nodes;\n      for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {\n        var node = nodes[reverse ? maxIndex - ii : ii];\n        if (node && node.iterate(fn, reverse) === false) {\n          return false;\n        }\n      }\n    };\n\n  // eslint-disable-next-line no-unused-vars\n  ValueNode.prototype.iterate = function (fn, reverse) {\n    return fn(this.entry);\n  };\n\n  var MapIterator = /*@__PURE__*/(function (Iterator) {\n    function MapIterator(map, type, reverse) {\n      this._type = type;\n      this._reverse = reverse;\n      this._stack = map._root && mapIteratorFrame(map._root);\n    }\n\n    if ( Iterator ) MapIterator.__proto__ = Iterator;\n    MapIterator.prototype = Object.create( Iterator && Iterator.prototype );\n    MapIterator.prototype.constructor = MapIterator;\n\n    MapIterator.prototype.next = function next () {\n      var type = this._type;\n      var stack = this._stack;\n      while (stack) {\n        var node = stack.node;\n        var index = stack.index++;\n        var maxIndex = (void 0);\n        if (node.entry) {\n          if (index === 0) {\n            return mapIteratorValue(type, node.entry);\n          }\n        } else if (node.entries) {\n          maxIndex = node.entries.length - 1;\n          if (index <= maxIndex) {\n            return mapIteratorValue(\n              type,\n              node.entries[this._reverse ? maxIndex - index : index]\n            );\n          }\n        } else {\n          maxIndex = node.nodes.length - 1;\n          if (index <= maxIndex) {\n            var subNode = node.nodes[this._reverse ? maxIndex - index : index];\n            if (subNode) {\n              if (subNode.entry) {\n                return mapIteratorValue(type, subNode.entry);\n              }\n              stack = this._stack = mapIteratorFrame(subNode, stack);\n            }\n            continue;\n          }\n        }\n        stack = this._stack = this._stack.__prev;\n      }\n      return iteratorDone();\n    };\n\n    return MapIterator;\n  }(Iterator));\n\n  function mapIteratorValue(type, entry) {\n    return iteratorValue(type, entry[0], entry[1]);\n  }\n\n  function mapIteratorFrame(node, prev) {\n    return {\n      node: node,\n      index: 0,\n      __prev: prev,\n    };\n  }\n\n  function makeMap(size, root, ownerID, hash) {\n    var map = Object.create(MapPrototype);\n    map.size = size;\n    map._root = root;\n    map.__ownerID = ownerID;\n    map.__hash = hash;\n    map.__altered = false;\n    return map;\n  }\n\n  var EMPTY_MAP;\n  function emptyMap() {\n    return EMPTY_MAP || (EMPTY_MAP = makeMap(0));\n  }\n\n  function updateMap(map, k, v) {\n    var newRoot;\n    var newSize;\n    if (!map._root) {\n      if (v === NOT_SET) {\n        return map;\n      }\n      newSize = 1;\n      newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]);\n    } else {\n      var didChangeSize = MakeRef();\n      var didAlter = MakeRef();\n      newRoot = updateNode(\n        map._root,\n        map.__ownerID,\n        0,\n        undefined,\n        k,\n        v,\n        didChangeSize,\n        didAlter\n      );\n      if (!didAlter.value) {\n        return map;\n      }\n      newSize = map.size + (didChangeSize.value ? (v === NOT_SET ? -1 : 1) : 0);\n    }\n    if (map.__ownerID) {\n      map.size = newSize;\n      map._root = newRoot;\n      map.__hash = undefined;\n      map.__altered = true;\n      return map;\n    }\n    return newRoot ? makeMap(newSize, newRoot) : emptyMap();\n  }\n\n  function updateNode(\n    node,\n    ownerID,\n    shift,\n    keyHash,\n    key,\n    value,\n    didChangeSize,\n    didAlter\n  ) {\n    if (!node) {\n      if (value === NOT_SET) {\n        return node;\n      }\n      SetRef(didAlter);\n      SetRef(didChangeSize);\n      return new ValueNode(ownerID, keyHash, [key, value]);\n    }\n    return node.update(\n      ownerID,\n      shift,\n      keyHash,\n      key,\n      value,\n      didChangeSize,\n      didAlter\n    );\n  }\n\n  function isLeafNode(node) {\n    return (\n      node.constructor === ValueNode || node.constructor === HashCollisionNode\n    );\n  }\n\n  function mergeIntoNode(node, ownerID, shift, keyHash, entry) {\n    if (node.keyHash === keyHash) {\n      return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);\n    }\n\n    var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;\n    var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;\n\n    var newNode;\n    var nodes =\n      idx1 === idx2\n        ? [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)]\n        : ((newNode = new ValueNode(ownerID, keyHash, entry)),\n          idx1 < idx2 ? [node, newNode] : [newNode, node]);\n\n    return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes);\n  }\n\n  function createNodes(ownerID, entries, key, value) {\n    if (!ownerID) {\n      ownerID = new OwnerID();\n    }\n    var node = new ValueNode(ownerID, hash(key), [key, value]);\n    for (var ii = 0; ii < entries.length; ii++) {\n      var entry = entries[ii];\n      node = node.update(ownerID, 0, undefined, entry[0], entry[1]);\n    }\n    return node;\n  }\n\n  function packNodes(ownerID, nodes, count, excluding) {\n    var bitmap = 0;\n    var packedII = 0;\n    var packedNodes = new Array(count);\n    for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) {\n      var node = nodes[ii];\n      if (node !== undefined && ii !== excluding) {\n        bitmap |= bit;\n        packedNodes[packedII++] = node;\n      }\n    }\n    return new BitmapIndexedNode(ownerID, bitmap, packedNodes);\n  }\n\n  function expandNodes(ownerID, nodes, bitmap, including, node) {\n    var count = 0;\n    var expandedNodes = new Array(SIZE);\n    for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {\n      expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined;\n    }\n    expandedNodes[including] = node;\n    return new HashArrayMapNode(ownerID, count + 1, expandedNodes);\n  }\n\n  function popCount(x) {\n    x -= (x >> 1) & 0x55555555;\n    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);\n    x = (x + (x >> 4)) & 0x0f0f0f0f;\n    x += x >> 8;\n    x += x >> 16;\n    return x & 0x7f;\n  }\n\n  function setAt(array, idx, val, canEdit) {\n    var newArray = canEdit ? array : arrCopy(array);\n    newArray[idx] = val;\n    return newArray;\n  }\n\n  function spliceIn(array, idx, val, canEdit) {\n    var newLen = array.length + 1;\n    if (canEdit && idx + 1 === newLen) {\n      array[idx] = val;\n      return array;\n    }\n    var newArray = new Array(newLen);\n    var after = 0;\n    for (var ii = 0; ii < newLen; ii++) {\n      if (ii === idx) {\n        newArray[ii] = val;\n        after = -1;\n      } else {\n        newArray[ii] = array[ii + after];\n      }\n    }\n    return newArray;\n  }\n\n  function spliceOut(array, idx, canEdit) {\n    var newLen = array.length - 1;\n    if (canEdit && idx === newLen) {\n      array.pop();\n      return array;\n    }\n    var newArray = new Array(newLen);\n    var after = 0;\n    for (var ii = 0; ii < newLen; ii++) {\n      if (ii === idx) {\n        after = 1;\n      }\n      newArray[ii] = array[ii + after];\n    }\n    return newArray;\n  }\n\n  var MAX_ARRAY_MAP_SIZE = SIZE / 4;\n  var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;\n  var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;\n\n  var IS_LIST_SYMBOL = '@@__IMMUTABLE_LIST__@@';\n\n  function isList(maybeList) {\n    return Boolean(maybeList && maybeList[IS_LIST_SYMBOL]);\n  }\n\n  var List = /*@__PURE__*/(function (IndexedCollection) {\n    function List(value) {\n      var empty = emptyList();\n      if (value === undefined || value === null) {\n        return empty;\n      }\n      if (isList(value)) {\n        return value;\n      }\n      var iter = IndexedCollection(value);\n      var size = iter.size;\n      if (size === 0) {\n        return empty;\n      }\n      assertNotInfinite(size);\n      if (size > 0 && size < SIZE) {\n        return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));\n      }\n      return empty.withMutations(function (list) {\n        list.setSize(size);\n        iter.forEach(function (v, i) { return list.set(i, v); });\n      });\n    }\n\n    if ( IndexedCollection ) List.__proto__ = IndexedCollection;\n    List.prototype = Object.create( IndexedCollection && IndexedCollection.prototype );\n    List.prototype.constructor = List;\n\n    List.of = function of (/*...values*/) {\n      return this(arguments);\n    };\n\n    List.prototype.toString = function toString () {\n      return this.__toString('List [', ']');\n    };\n\n    // @pragma Access\n\n    List.prototype.get = function get (index, notSetValue) {\n      index = wrapIndex(this, index);\n      if (index >= 0 && index < this.size) {\n        index += this._origin;\n        var node = listNodeFor(this, index);\n        return node && node.array[index & MASK];\n      }\n      return notSetValue;\n    };\n\n    // @pragma Modification\n\n    List.prototype.set = function set (index, value) {\n      return updateList(this, index, value);\n    };\n\n    List.prototype.remove = function remove (index) {\n      return !this.has(index)\n        ? this\n        : index === 0\n        ? this.shift()\n        : index === this.size - 1\n        ? this.pop()\n        : this.splice(index, 1);\n    };\n\n    List.prototype.insert = function insert (index, value) {\n      return this.splice(index, 0, value);\n    };\n\n    List.prototype.clear = function clear () {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = this._origin = this._capacity = 0;\n        this._level = SHIFT;\n        this._root = this._tail = this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyList();\n    };\n\n    List.prototype.push = function push (/*...values*/) {\n      var values = arguments;\n      var oldSize = this.size;\n      return this.withMutations(function (list) {\n        setListBounds(list, 0, oldSize + values.length);\n        for (var ii = 0; ii < values.length; ii++) {\n          list.set(oldSize + ii, values[ii]);\n        }\n      });\n    };\n\n    List.prototype.pop = function pop () {\n      return setListBounds(this, 0, -1);\n    };\n\n    List.prototype.unshift = function unshift (/*...values*/) {\n      var values = arguments;\n      return this.withMutations(function (list) {\n        setListBounds(list, -values.length);\n        for (var ii = 0; ii < values.length; ii++) {\n          list.set(ii, values[ii]);\n        }\n      });\n    };\n\n    List.prototype.shift = function shift () {\n      return setListBounds(this, 1);\n    };\n\n    // @pragma Composition\n\n    List.prototype.concat = function concat (/*...collections*/) {\n      var arguments$1 = arguments;\n\n      var seqs = [];\n      for (var i = 0; i < arguments.length; i++) {\n        var argument = arguments$1[i];\n        var seq = IndexedCollection(\n          typeof argument !== 'string' && hasIterator(argument)\n            ? argument\n            : [argument]\n        );\n        if (seq.size !== 0) {\n          seqs.push(seq);\n        }\n      }\n      if (seqs.length === 0) {\n        return this;\n      }\n      if (this.size === 0 && !this.__ownerID && seqs.length === 1) {\n        return this.constructor(seqs[0]);\n      }\n      return this.withMutations(function (list) {\n        seqs.forEach(function (seq) { return seq.forEach(function (value) { return list.push(value); }); });\n      });\n    };\n\n    List.prototype.setSize = function setSize (size) {\n      return setListBounds(this, 0, size);\n    };\n\n    List.prototype.map = function map (mapper, context) {\n      var this$1$1 = this;\n\n      return this.withMutations(function (list) {\n        for (var i = 0; i < this$1$1.size; i++) {\n          list.set(i, mapper.call(context, list.get(i), i, this$1$1));\n        }\n      });\n    };\n\n    // @pragma Iteration\n\n    List.prototype.slice = function slice (begin, end) {\n      var size = this.size;\n      if (wholeSlice(begin, end, size)) {\n        return this;\n      }\n      return setListBounds(\n        this,\n        resolveBegin(begin, size),\n        resolveEnd(end, size)\n      );\n    };\n\n    List.prototype.__iterator = function __iterator (type, reverse) {\n      var index = reverse ? this.size : 0;\n      var values = iterateList(this, reverse);\n      return new Iterator(function () {\n        var value = values();\n        return value === DONE\n          ? iteratorDone()\n          : iteratorValue(type, reverse ? --index : index++, value);\n      });\n    };\n\n    List.prototype.__iterate = function __iterate (fn, reverse) {\n      var index = reverse ? this.size : 0;\n      var values = iterateList(this, reverse);\n      var value;\n      while ((value = values()) !== DONE) {\n        if (fn(value, reverse ? --index : index++, this) === false) {\n          break;\n        }\n      }\n      return index;\n    };\n\n    List.prototype.__ensureOwner = function __ensureOwner (ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        if (this.size === 0) {\n          return emptyList();\n        }\n        this.__ownerID = ownerID;\n        this.__altered = false;\n        return this;\n      }\n      return makeList(\n        this._origin,\n        this._capacity,\n        this._level,\n        this._root,\n        this._tail,\n        ownerID,\n        this.__hash\n      );\n    };\n\n    return List;\n  }(IndexedCollection));\n\n  List.isList = isList;\n\n  var ListPrototype = List.prototype;\n  ListPrototype[IS_LIST_SYMBOL] = true;\n  ListPrototype[DELETE] = ListPrototype.remove;\n  ListPrototype.merge = ListPrototype.concat;\n  ListPrototype.setIn = setIn;\n  ListPrototype.deleteIn = ListPrototype.removeIn = deleteIn;\n  ListPrototype.update = update;\n  ListPrototype.updateIn = updateIn;\n  ListPrototype.mergeIn = mergeIn;\n  ListPrototype.mergeDeepIn = mergeDeepIn;\n  ListPrototype.withMutations = withMutations;\n  ListPrototype.wasAltered = wasAltered;\n  ListPrototype.asImmutable = asImmutable;\n  ListPrototype['@@transducer/init'] = ListPrototype.asMutable = asMutable;\n  ListPrototype['@@transducer/step'] = function (result, arr) {\n    return result.push(arr);\n  };\n  ListPrototype['@@transducer/result'] = function (obj) {\n    return obj.asImmutable();\n  };\n\n  var VNode = function VNode(array, ownerID) {\n    this.array = array;\n    this.ownerID = ownerID;\n  };\n\n  // TODO: seems like these methods are very similar\n\n  VNode.prototype.removeBefore = function removeBefore (ownerID, level, index) {\n    if (index === level ? 1 << level : this.array.length === 0) {\n      return this;\n    }\n    var originIndex = (index >>> level) & MASK;\n    if (originIndex >= this.array.length) {\n      return new VNode([], ownerID);\n    }\n    var removingFirst = originIndex === 0;\n    var newChild;\n    if (level > 0) {\n      var oldChild = this.array[originIndex];\n      newChild =\n        oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);\n      if (newChild === oldChild && removingFirst) {\n        return this;\n      }\n    }\n    if (removingFirst && !newChild) {\n      return this;\n    }\n    var editable = editableVNode(this, ownerID);\n    if (!removingFirst) {\n      for (var ii = 0; ii < originIndex; ii++) {\n        editable.array[ii] = undefined;\n      }\n    }\n    if (newChild) {\n      editable.array[originIndex] = newChild;\n    }\n    return editable;\n  };\n\n  VNode.prototype.removeAfter = function removeAfter (ownerID, level, index) {\n    if (index === (level ? 1 << level : 0) || this.array.length === 0) {\n      return this;\n    }\n    var sizeIndex = ((index - 1) >>> level) & MASK;\n    if (sizeIndex >= this.array.length) {\n      return this;\n    }\n\n    var newChild;\n    if (level > 0) {\n      var oldChild = this.array[sizeIndex];\n      newChild =\n        oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);\n      if (newChild === oldChild && sizeIndex === this.array.length - 1) {\n        return this;\n      }\n    }\n\n    var editable = editableVNode(this, ownerID);\n    editable.array.splice(sizeIndex + 1);\n    if (newChild) {\n      editable.array[sizeIndex] = newChild;\n    }\n    return editable;\n  };\n\n  var DONE = {};\n\n  function iterateList(list, reverse) {\n    var left = list._origin;\n    var right = list._capacity;\n    var tailPos = getTailOffset(right);\n    var tail = list._tail;\n\n    return iterateNodeOrLeaf(list._root, list._level, 0);\n\n    function iterateNodeOrLeaf(node, level, offset) {\n      return level === 0\n        ? iterateLeaf(node, offset)\n        : iterateNode(node, level, offset);\n    }\n\n    function iterateLeaf(node, offset) {\n      var array = offset === tailPos ? tail && tail.array : node && node.array;\n      var from = offset > left ? 0 : left - offset;\n      var to = right - offset;\n      if (to > SIZE) {\n        to = SIZE;\n      }\n      return function () {\n        if (from === to) {\n          return DONE;\n        }\n        var idx = reverse ? --to : from++;\n        return array && array[idx];\n      };\n    }\n\n    function iterateNode(node, level, offset) {\n      var values;\n      var array = node && node.array;\n      var from = offset > left ? 0 : (left - offset) >> level;\n      var to = ((right - offset) >> level) + 1;\n      if (to > SIZE) {\n        to = SIZE;\n      }\n      return function () {\n        while (true) {\n          if (values) {\n            var value = values();\n            if (value !== DONE) {\n              return value;\n            }\n            values = null;\n          }\n          if (from === to) {\n            return DONE;\n          }\n          var idx = reverse ? --to : from++;\n          values = iterateNodeOrLeaf(\n            array && array[idx],\n            level - SHIFT,\n            offset + (idx << level)\n          );\n        }\n      };\n    }\n  }\n\n  function makeList(origin, capacity, level, root, tail, ownerID, hash) {\n    var list = Object.create(ListPrototype);\n    list.size = capacity - origin;\n    list._origin = origin;\n    list._capacity = capacity;\n    list._level = level;\n    list._root = root;\n    list._tail = tail;\n    list.__ownerID = ownerID;\n    list.__hash = hash;\n    list.__altered = false;\n    return list;\n  }\n\n  var EMPTY_LIST;\n  function emptyList() {\n    return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT));\n  }\n\n  function updateList(list, index, value) {\n    index = wrapIndex(list, index);\n\n    if (index !== index) {\n      return list;\n    }\n\n    if (index >= list.size || index < 0) {\n      return list.withMutations(function (list) {\n        index < 0\n          ? setListBounds(list, index).set(0, value)\n          : setListBounds(list, 0, index + 1).set(index, value);\n      });\n    }\n\n    index += list._origin;\n\n    var newTail = list._tail;\n    var newRoot = list._root;\n    var didAlter = MakeRef();\n    if (index >= getTailOffset(list._capacity)) {\n      newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter);\n    } else {\n      newRoot = updateVNode(\n        newRoot,\n        list.__ownerID,\n        list._level,\n        index,\n        value,\n        didAlter\n      );\n    }\n\n    if (!didAlter.value) {\n      return list;\n    }\n\n    if (list.__ownerID) {\n      list._root = newRoot;\n      list._tail = newTail;\n      list.__hash = undefined;\n      list.__altered = true;\n      return list;\n    }\n    return makeList(list._origin, list._capacity, list._level, newRoot, newTail);\n  }\n\n  function updateVNode(node, ownerID, level, index, value, didAlter) {\n    var idx = (index >>> level) & MASK;\n    var nodeHas = node && idx < node.array.length;\n    if (!nodeHas && value === undefined) {\n      return node;\n    }\n\n    var newNode;\n\n    if (level > 0) {\n      var lowerNode = node && node.array[idx];\n      var newLowerNode = updateVNode(\n        lowerNode,\n        ownerID,\n        level - SHIFT,\n        index,\n        value,\n        didAlter\n      );\n      if (newLowerNode === lowerNode) {\n        return node;\n      }\n      newNode = editableVNode(node, ownerID);\n      newNode.array[idx] = newLowerNode;\n      return newNode;\n    }\n\n    if (nodeHas && node.array[idx] === value) {\n      return node;\n    }\n\n    if (didAlter) {\n      SetRef(didAlter);\n    }\n\n    newNode = editableVNode(node, ownerID);\n    if (value === undefined && idx === newNode.array.length - 1) {\n      newNode.array.pop();\n    } else {\n      newNode.array[idx] = value;\n    }\n    return newNode;\n  }\n\n  function editableVNode(node, ownerID) {\n    if (ownerID && node && ownerID === node.ownerID) {\n      return node;\n    }\n    return new VNode(node ? node.array.slice() : [], ownerID);\n  }\n\n  function listNodeFor(list, rawIndex) {\n    if (rawIndex >= getTailOffset(list._capacity)) {\n      return list._tail;\n    }\n    if (rawIndex < 1 << (list._level + SHIFT)) {\n      var node = list._root;\n      var level = list._level;\n      while (node && level > 0) {\n        node = node.array[(rawIndex >>> level) & MASK];\n        level -= SHIFT;\n      }\n      return node;\n    }\n  }\n\n  function setListBounds(list, begin, end) {\n    // Sanitize begin & end using this shorthand for ToInt32(argument)\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32\n    if (begin !== undefined) {\n      begin |= 0;\n    }\n    if (end !== undefined) {\n      end |= 0;\n    }\n    var owner = list.__ownerID || new OwnerID();\n    var oldOrigin = list._origin;\n    var oldCapacity = list._capacity;\n    var newOrigin = oldOrigin + begin;\n    var newCapacity =\n      end === undefined\n        ? oldCapacity\n        : end < 0\n        ? oldCapacity + end\n        : oldOrigin + end;\n    if (newOrigin === oldOrigin && newCapacity === oldCapacity) {\n      return list;\n    }\n\n    // If it's going to end after it starts, it's empty.\n    if (newOrigin >= newCapacity) {\n      return list.clear();\n    }\n\n    var newLevel = list._level;\n    var newRoot = list._root;\n\n    // New origin might need creating a higher root.\n    var offsetShift = 0;\n    while (newOrigin + offsetShift < 0) {\n      newRoot = new VNode(\n        newRoot && newRoot.array.length ? [undefined, newRoot] : [],\n        owner\n      );\n      newLevel += SHIFT;\n      offsetShift += 1 << newLevel;\n    }\n    if (offsetShift) {\n      newOrigin += offsetShift;\n      oldOrigin += offsetShift;\n      newCapacity += offsetShift;\n      oldCapacity += offsetShift;\n    }\n\n    var oldTailOffset = getTailOffset(oldCapacity);\n    var newTailOffset = getTailOffset(newCapacity);\n\n    // New size might need creating a higher root.\n    while (newTailOffset >= 1 << (newLevel + SHIFT)) {\n      newRoot = new VNode(\n        newRoot && newRoot.array.length ? [newRoot] : [],\n        owner\n      );\n      newLevel += SHIFT;\n    }\n\n    // Locate or create the new tail.\n    var oldTail = list._tail;\n    var newTail =\n      newTailOffset < oldTailOffset\n        ? listNodeFor(list, newCapacity - 1)\n        : newTailOffset > oldTailOffset\n        ? new VNode([], owner)\n        : oldTail;\n\n    // Merge Tail into tree.\n    if (\n      oldTail &&\n      newTailOffset > oldTailOffset &&\n      newOrigin < oldCapacity &&\n      oldTail.array.length\n    ) {\n      newRoot = editableVNode(newRoot, owner);\n      var node = newRoot;\n      for (var level = newLevel; level > SHIFT; level -= SHIFT) {\n        var idx = (oldTailOffset >>> level) & MASK;\n        node = node.array[idx] = editableVNode(node.array[idx], owner);\n      }\n      node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail;\n    }\n\n    // If the size has been reduced, there's a chance the tail needs to be trimmed.\n    if (newCapacity < oldCapacity) {\n      newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);\n    }\n\n    // If the new origin is within the tail, then we do not need a root.\n    if (newOrigin >= newTailOffset) {\n      newOrigin -= newTailOffset;\n      newCapacity -= newTailOffset;\n      newLevel = SHIFT;\n      newRoot = null;\n      newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);\n\n      // Otherwise, if the root has been trimmed, garbage collect.\n    } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {\n      offsetShift = 0;\n\n      // Identify the new top root node of the subtree of the old root.\n      while (newRoot) {\n        var beginIndex = (newOrigin >>> newLevel) & MASK;\n        if ((beginIndex !== newTailOffset >>> newLevel) & MASK) {\n          break;\n        }\n        if (beginIndex) {\n          offsetShift += (1 << newLevel) * beginIndex;\n        }\n        newLevel -= SHIFT;\n        newRoot = newRoot.array[beginIndex];\n      }\n\n      // Trim the new sides of the new root.\n      if (newRoot && newOrigin > oldOrigin) {\n        newRoot = newRoot.removeBefore(owner, newLevel, newOrigin - offsetShift);\n      }\n      if (newRoot && newTailOffset < oldTailOffset) {\n        newRoot = newRoot.removeAfter(\n          owner,\n          newLevel,\n          newTailOffset - offsetShift\n        );\n      }\n      if (offsetShift) {\n        newOrigin -= offsetShift;\n        newCapacity -= offsetShift;\n      }\n    }\n\n    if (list.__ownerID) {\n      list.size = newCapacity - newOrigin;\n      list._origin = newOrigin;\n      list._capacity = newCapacity;\n      list._level = newLevel;\n      list._root = newRoot;\n      list._tail = newTail;\n      list.__hash = undefined;\n      list.__altered = true;\n      return list;\n    }\n    return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);\n  }\n\n  function getTailOffset(size) {\n    return size < SIZE ? 0 : ((size - 1) >>> SHIFT) << SHIFT;\n  }\n\n  var OrderedMap = /*@__PURE__*/(function (Map) {\n    function OrderedMap(value) {\n      return value === undefined || value === null\n        ? emptyOrderedMap()\n        : isOrderedMap(value)\n        ? value\n        : emptyOrderedMap().withMutations(function (map) {\n            var iter = KeyedCollection(value);\n            assertNotInfinite(iter.size);\n            iter.forEach(function (v, k) { return map.set(k, v); });\n          });\n    }\n\n    if ( Map ) OrderedMap.__proto__ = Map;\n    OrderedMap.prototype = Object.create( Map && Map.prototype );\n    OrderedMap.prototype.constructor = OrderedMap;\n\n    OrderedMap.of = function of (/*...values*/) {\n      return this(arguments);\n    };\n\n    OrderedMap.prototype.toString = function toString () {\n      return this.__toString('OrderedMap {', '}');\n    };\n\n    // @pragma Access\n\n    OrderedMap.prototype.get = function get (k, notSetValue) {\n      var index = this._map.get(k);\n      return index !== undefined ? this._list.get(index)[1] : notSetValue;\n    };\n\n    // @pragma Modification\n\n    OrderedMap.prototype.clear = function clear () {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._map.clear();\n        this._list.clear();\n        this.__altered = true;\n        return this;\n      }\n      return emptyOrderedMap();\n    };\n\n    OrderedMap.prototype.set = function set (k, v) {\n      return updateOrderedMap(this, k, v);\n    };\n\n    OrderedMap.prototype.remove = function remove (k) {\n      return updateOrderedMap(this, k, NOT_SET);\n    };\n\n    OrderedMap.prototype.__iterate = function __iterate (fn, reverse) {\n      var this$1$1 = this;\n\n      return this._list.__iterate(\n        function (entry) { return entry && fn(entry[1], entry[0], this$1$1); },\n        reverse\n      );\n    };\n\n    OrderedMap.prototype.__iterator = function __iterator (type, reverse) {\n      return this._list.fromEntrySeq().__iterator(type, reverse);\n    };\n\n    OrderedMap.prototype.__ensureOwner = function __ensureOwner (ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      var newMap = this._map.__ensureOwner(ownerID);\n      var newList = this._list.__ensureOwner(ownerID);\n      if (!ownerID) {\n        if (this.size === 0) {\n          return emptyOrderedMap();\n        }\n        this.__ownerID = ownerID;\n        this.__altered = false;\n        this._map = newMap;\n        this._list = newList;\n        return this;\n      }\n      return makeOrderedMap(newMap, newList, ownerID, this.__hash);\n    };\n\n    return OrderedMap;\n  }(Map));\n\n  OrderedMap.isOrderedMap = isOrderedMap;\n\n  OrderedMap.prototype[IS_ORDERED_SYMBOL] = true;\n  OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;\n\n  function makeOrderedMap(map, list, ownerID, hash) {\n    var omap = Object.create(OrderedMap.prototype);\n    omap.size = map ? map.size : 0;\n    omap._map = map;\n    omap._list = list;\n    omap.__ownerID = ownerID;\n    omap.__hash = hash;\n    omap.__altered = false;\n    return omap;\n  }\n\n  var EMPTY_ORDERED_MAP;\n  function emptyOrderedMap() {\n    return (\n      EMPTY_ORDERED_MAP ||\n      (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()))\n    );\n  }\n\n  function updateOrderedMap(omap, k, v) {\n    var map = omap._map;\n    var list = omap._list;\n    var i = map.get(k);\n    var has = i !== undefined;\n    var newMap;\n    var newList;\n    if (v === NOT_SET) {\n      // removed\n      if (!has) {\n        return omap;\n      }\n      if (list.size >= SIZE && list.size >= map.size * 2) {\n        newList = list.filter(function (entry, idx) { return entry !== undefined && i !== idx; });\n        newMap = newList\n          .toKeyedSeq()\n          .map(function (entry) { return entry[0]; })\n          .flip()\n          .toMap();\n        if (omap.__ownerID) {\n          newMap.__ownerID = newList.__ownerID = omap.__ownerID;\n        }\n      } else {\n        newMap = map.remove(k);\n        newList = i === list.size - 1 ? list.pop() : list.set(i, undefined);\n      }\n    } else if (has) {\n      if (v === list.get(i)[1]) {\n        return omap;\n      }\n      newMap = map;\n      newList = list.set(i, [k, v]);\n    } else {\n      newMap = map.set(k, list.size);\n      newList = list.set(list.size, [k, v]);\n    }\n    if (omap.__ownerID) {\n      omap.size = newMap.size;\n      omap._map = newMap;\n      omap._list = newList;\n      omap.__hash = undefined;\n      omap.__altered = true;\n      return omap;\n    }\n    return makeOrderedMap(newMap, newList);\n  }\n\n  var IS_STACK_SYMBOL = '@@__IMMUTABLE_STACK__@@';\n\n  function isStack(maybeStack) {\n    return Boolean(maybeStack && maybeStack[IS_STACK_SYMBOL]);\n  }\n\n  var Stack = /*@__PURE__*/(function (IndexedCollection) {\n    function Stack(value) {\n      return value === undefined || value === null\n        ? emptyStack()\n        : isStack(value)\n        ? value\n        : emptyStack().pushAll(value);\n    }\n\n    if ( IndexedCollection ) Stack.__proto__ = IndexedCollection;\n    Stack.prototype = Object.create( IndexedCollection && IndexedCollection.prototype );\n    Stack.prototype.constructor = Stack;\n\n    Stack.of = function of (/*...values*/) {\n      return this(arguments);\n    };\n\n    Stack.prototype.toString = function toString () {\n      return this.__toString('Stack [', ']');\n    };\n\n    // @pragma Access\n\n    Stack.prototype.get = function get (index, notSetValue) {\n      var head = this._head;\n      index = wrapIndex(this, index);\n      while (head && index--) {\n        head = head.next;\n      }\n      return head ? head.value : notSetValue;\n    };\n\n    Stack.prototype.peek = function peek () {\n      return this._head && this._head.value;\n    };\n\n    // @pragma Modification\n\n    Stack.prototype.push = function push (/*...values*/) {\n      var arguments$1 = arguments;\n\n      if (arguments.length === 0) {\n        return this;\n      }\n      var newSize = this.size + arguments.length;\n      var head = this._head;\n      for (var ii = arguments.length - 1; ii >= 0; ii--) {\n        head = {\n          value: arguments$1[ii],\n          next: head,\n        };\n      }\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    Stack.prototype.pushAll = function pushAll (iter) {\n      iter = IndexedCollection(iter);\n      if (iter.size === 0) {\n        return this;\n      }\n      if (this.size === 0 && isStack(iter)) {\n        return iter;\n      }\n      assertNotInfinite(iter.size);\n      var newSize = this.size;\n      var head = this._head;\n      iter.__iterate(function (value) {\n        newSize++;\n        head = {\n          value: value,\n          next: head,\n        };\n      }, /* reverse */ true);\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    Stack.prototype.pop = function pop () {\n      return this.slice(1);\n    };\n\n    Stack.prototype.clear = function clear () {\n      if (this.size === 0) {\n        return this;\n      }\n      if (this.__ownerID) {\n        this.size = 0;\n        this._head = undefined;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return emptyStack();\n    };\n\n    Stack.prototype.slice = function slice (begin, end) {\n      if (wholeSlice(begin, end, this.size)) {\n        return this;\n      }\n      var resolvedBegin = resolveBegin(begin, this.size);\n      var resolvedEnd = resolveEnd(end, this.size);\n      if (resolvedEnd !== this.size) {\n        // super.slice(begin, end);\n        return IndexedCollection.prototype.slice.call(this, begin, end);\n      }\n      var newSize = this.size - resolvedBegin;\n      var head = this._head;\n      while (resolvedBegin--) {\n        head = head.next;\n      }\n      if (this.__ownerID) {\n        this.size = newSize;\n        this._head = head;\n        this.__hash = undefined;\n        this.__altered = true;\n        return this;\n      }\n      return makeStack(newSize, head);\n    };\n\n    // @pragma Mutability\n\n    Stack.prototype.__ensureOwner = function __ensureOwner (ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      if (!ownerID) {\n        if (this.size === 0) {\n          return emptyStack();\n        }\n        this.__ownerID = ownerID;\n        this.__altered = false;\n        return this;\n      }\n      return makeStack(this.size, this._head, ownerID, this.__hash);\n    };\n\n    // @pragma Iteration\n\n    Stack.prototype.__iterate = function __iterate (fn, reverse) {\n      var this$1$1 = this;\n\n      if (reverse) {\n        return new ArraySeq(this.toArray()).__iterate(\n          function (v, k) { return fn(v, k, this$1$1); },\n          reverse\n        );\n      }\n      var iterations = 0;\n      var node = this._head;\n      while (node) {\n        if (fn(node.value, iterations++, this) === false) {\n          break;\n        }\n        node = node.next;\n      }\n      return iterations;\n    };\n\n    Stack.prototype.__iterator = function __iterator (type, reverse) {\n      if (reverse) {\n        return new ArraySeq(this.toArray()).__iterator(type, reverse);\n      }\n      var iterations = 0;\n      var node = this._head;\n      return new Iterator(function () {\n        if (node) {\n          var value = node.value;\n          node = node.next;\n          return iteratorValue(type, iterations++, value);\n        }\n        return iteratorDone();\n      });\n    };\n\n    return Stack;\n  }(IndexedCollection));\n\n  Stack.isStack = isStack;\n\n  var StackPrototype = Stack.prototype;\n  StackPrototype[IS_STACK_SYMBOL] = true;\n  StackPrototype.shift = StackPrototype.pop;\n  StackPrototype.unshift = StackPrototype.push;\n  StackPrototype.unshiftAll = StackPrototype.pushAll;\n  StackPrototype.withMutations = withMutations;\n  StackPrototype.wasAltered = wasAltered;\n  StackPrototype.asImmutable = asImmutable;\n  StackPrototype['@@transducer/init'] = StackPrototype.asMutable = asMutable;\n  StackPrototype['@@transducer/step'] = function (result, arr) {\n    return result.unshift(arr);\n  };\n  StackPrototype['@@transducer/result'] = function (obj) {\n    return obj.asImmutable();\n  };\n\n  function makeStack(size, head, ownerID, hash) {\n    var map = Object.create(StackPrototype);\n    map.size = size;\n    map._head = head;\n    map.__ownerID = ownerID;\n    map.__hash = hash;\n    map.__altered = false;\n    return map;\n  }\n\n  var EMPTY_STACK;\n  function emptyStack() {\n    return EMPTY_STACK || (EMPTY_STACK = makeStack(0));\n  }\n\n  var IS_SET_SYMBOL = '@@__IMMUTABLE_SET__@@';\n\n  function isSet(maybeSet) {\n    return Boolean(maybeSet && maybeSet[IS_SET_SYMBOL]);\n  }\n\n  function isOrderedSet(maybeOrderedSet) {\n    return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);\n  }\n\n  function deepEqual(a, b) {\n    if (a === b) {\n      return true;\n    }\n\n    if (\n      !isCollection(b) ||\n      (a.size !== undefined && b.size !== undefined && a.size !== b.size) ||\n      (a.__hash !== undefined &&\n        b.__hash !== undefined &&\n        a.__hash !== b.__hash) ||\n      isKeyed(a) !== isKeyed(b) ||\n      isIndexed(a) !== isIndexed(b) ||\n      isOrdered(a) !== isOrdered(b)\n    ) {\n      return false;\n    }\n\n    if (a.size === 0 && b.size === 0) {\n      return true;\n    }\n\n    var notAssociative = !isAssociative(a);\n\n    if (isOrdered(a)) {\n      var entries = a.entries();\n      return (\n        b.every(function (v, k) {\n          var entry = entries.next().value;\n          return entry && is(entry[1], v) && (notAssociative || is(entry[0], k));\n        }) && entries.next().done\n      );\n    }\n\n    var flipped = false;\n\n    if (a.size === undefined) {\n      if (b.size === undefined) {\n        if (typeof a.cacheResult === 'function') {\n          a.cacheResult();\n        }\n      } else {\n        flipped = true;\n        var _ = a;\n        a = b;\n        b = _;\n      }\n    }\n\n    var allEqual = true;\n    var bSize = b.__iterate(function (v, k) {\n      if (\n        notAssociative\n          ? !a.has(v)\n          : flipped\n          ? !is(v, a.get(k, NOT_SET))\n          : !is(a.get(k, NOT_SET), v)\n      ) {\n        allEqual = false;\n        return false;\n      }\n    });\n\n    return allEqual && a.size === bSize;\n  }\n\n  function mixin(ctor, methods) {\n    var keyCopier = function (key) {\n      ctor.prototype[key] = methods[key];\n    };\n    Object.keys(methods).forEach(keyCopier);\n    Object.getOwnPropertySymbols &&\n      Object.getOwnPropertySymbols(methods).forEach(keyCopier);\n    return ctor;\n  }\n\n  function toJS(value) {\n    if (!value || typeof value !== 'object') {\n      return value;\n    }\n    if (!isCollection(value)) {\n      if (!isDataStructure(value)) {\n        return value;\n      }\n      value = Seq(value);\n    }\n    if (isKeyed(value)) {\n      var result$1 = {};\n      value.__iterate(function (v, k) {\n        result$1[k] = toJS(v);\n      });\n      return result$1;\n    }\n    var result = [];\n    value.__iterate(function (v) {\n      result.push(toJS(v));\n    });\n    return result;\n  }\n\n  var Set = /*@__PURE__*/(function (SetCollection) {\n    function Set(value) {\n      return value === undefined || value === null\n        ? emptySet()\n        : isSet(value) && !isOrdered(value)\n        ? value\n        : emptySet().withMutations(function (set) {\n            var iter = SetCollection(value);\n            assertNotInfinite(iter.size);\n            iter.forEach(function (v) { return set.add(v); });\n          });\n    }\n\n    if ( SetCollection ) Set.__proto__ = SetCollection;\n    Set.prototype = Object.create( SetCollection && SetCollection.prototype );\n    Set.prototype.constructor = Set;\n\n    Set.of = function of (/*...values*/) {\n      return this(arguments);\n    };\n\n    Set.fromKeys = function fromKeys (value) {\n      return this(KeyedCollection(value).keySeq());\n    };\n\n    Set.intersect = function intersect (sets) {\n      sets = Collection(sets).toArray();\n      return sets.length\n        ? SetPrototype.intersect.apply(Set(sets.pop()), sets)\n        : emptySet();\n    };\n\n    Set.union = function union (sets) {\n      sets = Collection(sets).toArray();\n      return sets.length\n        ? SetPrototype.union.apply(Set(sets.pop()), sets)\n        : emptySet();\n    };\n\n    Set.prototype.toString = function toString () {\n      return this.__toString('Set {', '}');\n    };\n\n    // @pragma Access\n\n    Set.prototype.has = function has (value) {\n      return this._map.has(value);\n    };\n\n    // @pragma Modification\n\n    Set.prototype.add = function add (value) {\n      return updateSet(this, this._map.set(value, value));\n    };\n\n    Set.prototype.remove = function remove (value) {\n      return updateSet(this, this._map.remove(value));\n    };\n\n    Set.prototype.clear = function clear () {\n      return updateSet(this, this._map.clear());\n    };\n\n    // @pragma Composition\n\n    Set.prototype.map = function map (mapper, context) {\n      var this$1$1 = this;\n\n      // keep track if the set is altered by the map function\n      var didChanges = false;\n\n      var newMap = updateSet(\n        this,\n        this._map.mapEntries(function (ref) {\n          var v = ref[1];\n\n          var mapped = mapper.call(context, v, v, this$1$1);\n\n          if (mapped !== v) {\n            didChanges = true;\n          }\n\n          return [mapped, mapped];\n        }, context)\n      );\n\n      return didChanges ? newMap : this;\n    };\n\n    Set.prototype.union = function union () {\n      var iters = [], len = arguments.length;\n      while ( len-- ) iters[ len ] = arguments[ len ];\n\n      iters = iters.filter(function (x) { return x.size !== 0; });\n      if (iters.length === 0) {\n        return this;\n      }\n      if (this.size === 0 && !this.__ownerID && iters.length === 1) {\n        return this.constructor(iters[0]);\n      }\n      return this.withMutations(function (set) {\n        for (var ii = 0; ii < iters.length; ii++) {\n          SetCollection(iters[ii]).forEach(function (value) { return set.add(value); });\n        }\n      });\n    };\n\n    Set.prototype.intersect = function intersect () {\n      var iters = [], len = arguments.length;\n      while ( len-- ) iters[ len ] = arguments[ len ];\n\n      if (iters.length === 0) {\n        return this;\n      }\n      iters = iters.map(function (iter) { return SetCollection(iter); });\n      var toRemove = [];\n      this.forEach(function (value) {\n        if (!iters.every(function (iter) { return iter.includes(value); })) {\n          toRemove.push(value);\n        }\n      });\n      return this.withMutations(function (set) {\n        toRemove.forEach(function (value) {\n          set.remove(value);\n        });\n      });\n    };\n\n    Set.prototype.subtract = function subtract () {\n      var iters = [], len = arguments.length;\n      while ( len-- ) iters[ len ] = arguments[ len ];\n\n      if (iters.length === 0) {\n        return this;\n      }\n      iters = iters.map(function (iter) { return SetCollection(iter); });\n      var toRemove = [];\n      this.forEach(function (value) {\n        if (iters.some(function (iter) { return iter.includes(value); })) {\n          toRemove.push(value);\n        }\n      });\n      return this.withMutations(function (set) {\n        toRemove.forEach(function (value) {\n          set.remove(value);\n        });\n      });\n    };\n\n    Set.prototype.sort = function sort (comparator) {\n      // Late binding\n      return OrderedSet(sortFactory(this, comparator));\n    };\n\n    Set.prototype.sortBy = function sortBy (mapper, comparator) {\n      // Late binding\n      return OrderedSet(sortFactory(this, comparator, mapper));\n    };\n\n    Set.prototype.wasAltered = function wasAltered () {\n      return this._map.wasAltered();\n    };\n\n    Set.prototype.__iterate = function __iterate (fn, reverse) {\n      var this$1$1 = this;\n\n      return this._map.__iterate(function (k) { return fn(k, k, this$1$1); }, reverse);\n    };\n\n    Set.prototype.__iterator = function __iterator (type, reverse) {\n      return this._map.__iterator(type, reverse);\n    };\n\n    Set.prototype.__ensureOwner = function __ensureOwner (ownerID) {\n      if (ownerID === this.__ownerID) {\n        return this;\n      }\n      var newMap = this._map.__ensureOwner(ownerID);\n      if (!ownerID) {\n        if (this.size === 0) {\n          return this.__empty();\n        }\n        this.__ownerID = ownerID;\n        this._map = newMap;\n        return this;\n      }\n      return this.__make(newMap, ownerID);\n    };\n\n    return Set;\n  }(SetCollection));\n\n  Set.isSet = isSet;\n\n  var SetPrototype = Set.prototype;\n  SetPrototype[IS_SET_SYMBOL] = true;\n  SetPrototype[DELETE] = SetPrototype.remove;\n  SetPrototype.merge = SetPrototype.concat = SetPrototype.union;\n  SetPrototype.withMutations = withMutations;\n  SetPrototype.asImmutable = asImmutable;\n  SetPrototype['@@transducer/init'] = SetPrototype.asMutable = asMutable;\n  SetPrototype['@@transducer/step'] = function (result, arr) {\n    return result.add(arr);\n  };\n  SetPrototype['@@transducer/result'] = function (obj) {\n    return obj.asImmutable();\n  };\n\n  SetPrototype.__empty = emptySet;\n  SetPrototype.__make = makeSet;\n\n  function updateSet(set, newMap) {\n    if (set.__ownerID) {\n      set.size = newMap.size;\n      set._map = newMap;\n      return set;\n    }\n    return newMap === set._map\n      ? set\n      : newMap.size === 0\n      ? set.__empty()\n      : set.__make(newMap);\n  }\n\n  function makeSet(map, ownerID) {\n    var set = Object.create(SetPrototype);\n    set.size = map ? map.size : 0;\n    set._map = map;\n    set.__ownerID = ownerID;\n    return set;\n  }\n\n  var EMPTY_SET;\n  function emptySet() {\n    return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));\n  }\n\n  /**\n   * Returns a lazy seq of nums from start (inclusive) to end\n   * (exclusive), by step, where start defaults to 0, step to 1, and end to\n   * infinity. When start is equal to end, returns empty list.\n   */\n  var Range = /*@__PURE__*/(function (IndexedSeq) {\n    function Range(start, end, step) {\n      if (!(this instanceof Range)) {\n        return new Range(start, end, step);\n      }\n      invariant(step !== 0, 'Cannot step a Range by 0');\n      start = start || 0;\n      if (end === undefined) {\n        end = Infinity;\n      }\n      step = step === undefined ? 1 : Math.abs(step);\n      if (end < start) {\n        step = -step;\n      }\n      this._start = start;\n      this._end = end;\n      this._step = step;\n      this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);\n      if (this.size === 0) {\n        if (EMPTY_RANGE) {\n          return EMPTY_RANGE;\n        }\n        EMPTY_RANGE = this;\n      }\n    }\n\n    if ( IndexedSeq ) Range.__proto__ = IndexedSeq;\n    Range.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );\n    Range.prototype.constructor = Range;\n\n    Range.prototype.toString = function toString () {\n      if (this.size === 0) {\n        return 'Range []';\n      }\n      return (\n        'Range [ ' +\n        this._start +\n        '...' +\n        this._end +\n        (this._step !== 1 ? ' by ' + this._step : '') +\n        ' ]'\n      );\n    };\n\n    Range.prototype.get = function get (index, notSetValue) {\n      return this.has(index)\n        ? this._start + wrapIndex(this, index) * this._step\n        : notSetValue;\n    };\n\n    Range.prototype.includes = function includes (searchValue) {\n      var possibleIndex = (searchValue - this._start) / this._step;\n      return (\n        possibleIndex >= 0 &&\n        possibleIndex < this.size &&\n        possibleIndex === Math.floor(possibleIndex)\n      );\n    };\n\n    Range.prototype.slice = function slice (begin, end) {\n      if (wholeSlice(begin, end, this.size)) {\n        return this;\n      }\n      begin = resolveBegin(begin, this.size);\n      end = resolveEnd(end, this.size);\n      if (end <= begin) {\n        return new Range(0, 0);\n      }\n      return new Range(\n        this.get(begin, this._end),\n        this.get(end, this._end),\n        this._step\n      );\n    };\n\n    Range.prototype.indexOf = function indexOf (searchValue) {\n      var offsetValue = searchValue - this._start;\n      if (offsetValue % this._step === 0) {\n        var index = offsetValue / this._step;\n        if (index >= 0 && index < this.size) {\n          return index;\n        }\n      }\n      return -1;\n    };\n\n    Range.prototype.lastIndexOf = function lastIndexOf (searchValue) {\n      return this.indexOf(searchValue);\n    };\n\n    Range.prototype.__iterate = function __iterate (fn, reverse) {\n      var size = this.size;\n      var step = this._step;\n      var value = reverse ? this._start + (size - 1) * step : this._start;\n      var i = 0;\n      while (i !== size) {\n        if (fn(value, reverse ? size - ++i : i++, this) === false) {\n          break;\n        }\n        value += reverse ? -step : step;\n      }\n      return i;\n    };\n\n    Range.prototype.__iterator = function __iterator (type, reverse) {\n      var size = this.size;\n      var step = this._step;\n      var value = reverse ? this._start + (size - 1) * step : this._start;\n      var i = 0;\n      return new Iterator(function () {\n        if (i === size) {\n          return iteratorDone();\n        }\n        var v = value;\n        value += reverse ? -step : step;\n        return iteratorValue(type, reverse ? size - ++i : i++, v);\n      });\n    };\n\n    Range.prototype.equals = function equals (other) {\n      return other instanceof Range\n        ? this._start === other._start &&\n            this._end === other._end &&\n            this._step === other._step\n        : deepEqual(this, other);\n    };\n\n    return Range;\n  }(IndexedSeq));\n\n  var EMPTY_RANGE;\n\n  function getIn$1(collection, searchKeyPath, notSetValue) {\n    var keyPath = coerceKeyPath(searchKeyPath);\n    var i = 0;\n    while (i !== keyPath.length) {\n      collection = get(collection, keyPath[i++], NOT_SET);\n      if (collection === NOT_SET) {\n        return notSetValue;\n      }\n    }\n    return collection;\n  }\n\n  function getIn(searchKeyPath, notSetValue) {\n    return getIn$1(this, searchKeyPath, notSetValue);\n  }\n\n  function hasIn$1(collection, keyPath) {\n    return getIn$1(collection, keyPath, NOT_SET) !== NOT_SET;\n  }\n\n  function hasIn(searchKeyPath) {\n    return hasIn$1(this, searchKeyPath);\n  }\n\n  function toObject() {\n    assertNotInfinite(this.size);\n    var object = {};\n    this.__iterate(function (v, k) {\n      object[k] = v;\n    });\n    return object;\n  }\n\n  // Note: all of these methods are deprecated.\n  Collection.isIterable = isCollection;\n  Collection.isKeyed = isKeyed;\n  Collection.isIndexed = isIndexed;\n  Collection.isAssociative = isAssociative;\n  Collection.isOrdered = isOrdered;\n\n  Collection.Iterator = Iterator;\n\n  mixin(Collection, {\n    // ### Conversion to other types\n\n    toArray: function toArray() {\n      assertNotInfinite(this.size);\n      var array = new Array(this.size || 0);\n      var useTuples = isKeyed(this);\n      var i = 0;\n      this.__iterate(function (v, k) {\n        // Keyed collections produce an array of tuples.\n        array[i++] = useTuples ? [k, v] : v;\n      });\n      return array;\n    },\n\n    toIndexedSeq: function toIndexedSeq() {\n      return new ToIndexedSequence(this);\n    },\n\n    toJS: function toJS$1() {\n      return toJS(this);\n    },\n\n    toKeyedSeq: function toKeyedSeq() {\n      return new ToKeyedSequence(this, true);\n    },\n\n    toMap: function toMap() {\n      // Use Late Binding here to solve the circular dependency.\n      return Map(this.toKeyedSeq());\n    },\n\n    toObject: toObject,\n\n    toOrderedMap: function toOrderedMap() {\n      // Use Late Binding here to solve the circular dependency.\n      return OrderedMap(this.toKeyedSeq());\n    },\n\n    toOrderedSet: function toOrderedSet() {\n      // Use Late Binding here to solve the circular dependency.\n      return OrderedSet(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toSet: function toSet() {\n      // Use Late Binding here to solve the circular dependency.\n      return Set(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toSetSeq: function toSetSeq() {\n      return new ToSetSequence(this);\n    },\n\n    toSeq: function toSeq() {\n      return isIndexed(this)\n        ? this.toIndexedSeq()\n        : isKeyed(this)\n        ? this.toKeyedSeq()\n        : this.toSetSeq();\n    },\n\n    toStack: function toStack() {\n      // Use Late Binding here to solve the circular dependency.\n      return Stack(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    toList: function toList() {\n      // Use Late Binding here to solve the circular dependency.\n      return List(isKeyed(this) ? this.valueSeq() : this);\n    },\n\n    // ### Common JavaScript methods and properties\n\n    toString: function toString() {\n      return '[Collection]';\n    },\n\n    __toString: function __toString(head, tail) {\n      if (this.size === 0) {\n        return head + tail;\n      }\n      return (\n        head +\n        ' ' +\n        this.toSeq().map(this.__toStringMapper).join(', ') +\n        ' ' +\n        tail\n      );\n    },\n\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    concat: function concat() {\n      var values = [], len = arguments.length;\n      while ( len-- ) values[ len ] = arguments[ len ];\n\n      return reify(this, concatFactory(this, values));\n    },\n\n    includes: function includes(searchValue) {\n      return this.some(function (value) { return is(value, searchValue); });\n    },\n\n    entries: function entries() {\n      return this.__iterator(ITERATE_ENTRIES);\n    },\n\n    every: function every(predicate, context) {\n      assertNotInfinite(this.size);\n      var returnValue = true;\n      this.__iterate(function (v, k, c) {\n        if (!predicate.call(context, v, k, c)) {\n          returnValue = false;\n          return false;\n        }\n      });\n      return returnValue;\n    },\n\n    filter: function filter(predicate, context) {\n      return reify(this, filterFactory(this, predicate, context, true));\n    },\n\n    find: function find(predicate, context, notSetValue) {\n      var entry = this.findEntry(predicate, context);\n      return entry ? entry[1] : notSetValue;\n    },\n\n    forEach: function forEach(sideEffect, context) {\n      assertNotInfinite(this.size);\n      return this.__iterate(context ? sideEffect.bind(context) : sideEffect);\n    },\n\n    join: function join(separator) {\n      assertNotInfinite(this.size);\n      separator = separator !== undefined ? '' + separator : ',';\n      var joined = '';\n      var isFirst = true;\n      this.__iterate(function (v) {\n        isFirst ? (isFirst = false) : (joined += separator);\n        joined += v !== null && v !== undefined ? v.toString() : '';\n      });\n      return joined;\n    },\n\n    keys: function keys() {\n      return this.__iterator(ITERATE_KEYS);\n    },\n\n    map: function map(mapper, context) {\n      return reify(this, mapFactory(this, mapper, context));\n    },\n\n    reduce: function reduce$1(reducer, initialReduction, context) {\n      return reduce(\n        this,\n        reducer,\n        initialReduction,\n        context,\n        arguments.length < 2,\n        false\n      );\n    },\n\n    reduceRight: function reduceRight(reducer, initialReduction, context) {\n      return reduce(\n        this,\n        reducer,\n        initialReduction,\n        context,\n        arguments.length < 2,\n        true\n      );\n    },\n\n    reverse: function reverse() {\n      return reify(this, reverseFactory(this, true));\n    },\n\n    slice: function slice(begin, end) {\n      return reify(this, sliceFactory(this, begin, end, true));\n    },\n\n    some: function some(predicate, context) {\n      return !this.every(not(predicate), context);\n    },\n\n    sort: function sort(comparator) {\n      return reify(this, sortFactory(this, comparator));\n    },\n\n    values: function values() {\n      return this.__iterator(ITERATE_VALUES);\n    },\n\n    // ### More sequential methods\n\n    butLast: function butLast() {\n      return this.slice(0, -1);\n    },\n\n    isEmpty: function isEmpty() {\n      return this.size !== undefined ? this.size === 0 : !this.some(function () { return true; });\n    },\n\n    count: function count(predicate, context) {\n      return ensureSize(\n        predicate ? this.toSeq().filter(predicate, context) : this\n      );\n    },\n\n    countBy: function countBy(grouper, context) {\n      return countByFactory(this, grouper, context);\n    },\n\n    equals: function equals(other) {\n      return deepEqual(this, other);\n    },\n\n    entrySeq: function entrySeq() {\n      var collection = this;\n      if (collection._cache) {\n        // We cache as an entries array, so we can just return the cache!\n        return new ArraySeq(collection._cache);\n      }\n      var entriesSequence = collection.toSeq().map(entryMapper).toIndexedSeq();\n      entriesSequence.fromEntrySeq = function () { return collection.toSeq(); };\n      return entriesSequence;\n    },\n\n    filterNot: function filterNot(predicate, context) {\n      return this.filter(not(predicate), context);\n    },\n\n    findEntry: function findEntry(predicate, context, notSetValue) {\n      var found = notSetValue;\n      this.__iterate(function (v, k, c) {\n        if (predicate.call(context, v, k, c)) {\n          found = [k, v];\n          return false;\n        }\n      });\n      return found;\n    },\n\n    findKey: function findKey(predicate, context) {\n      var entry = this.findEntry(predicate, context);\n      return entry && entry[0];\n    },\n\n    findLast: function findLast(predicate, context, notSetValue) {\n      return this.toKeyedSeq().reverse().find(predicate, context, notSetValue);\n    },\n\n    findLastEntry: function findLastEntry(predicate, context, notSetValue) {\n      return this.toKeyedSeq()\n        .reverse()\n        .findEntry(predicate, context, notSetValue);\n    },\n\n    findLastKey: function findLastKey(predicate, context) {\n      return this.toKeyedSeq().reverse().findKey(predicate, context);\n    },\n\n    first: function first(notSetValue) {\n      return this.find(returnTrue, null, notSetValue);\n    },\n\n    flatMap: function flatMap(mapper, context) {\n      return reify(this, flatMapFactory(this, mapper, context));\n    },\n\n    flatten: function flatten(depth) {\n      return reify(this, flattenFactory(this, depth, true));\n    },\n\n    fromEntrySeq: function fromEntrySeq() {\n      return new FromEntriesSequence(this);\n    },\n\n    get: function get(searchKey, notSetValue) {\n      return this.find(function (_, key) { return is(key, searchKey); }, undefined, notSetValue);\n    },\n\n    getIn: getIn,\n\n    groupBy: function groupBy(grouper, context) {\n      return groupByFactory(this, grouper, context);\n    },\n\n    has: function has(searchKey) {\n      return this.get(searchKey, NOT_SET) !== NOT_SET;\n    },\n\n    hasIn: hasIn,\n\n    isSubset: function isSubset(iter) {\n      iter = typeof iter.includes === 'function' ? iter : Collection(iter);\n      return this.every(function (value) { return iter.includes(value); });\n    },\n\n    isSuperset: function isSuperset(iter) {\n      iter = typeof iter.isSubset === 'function' ? iter : Collection(iter);\n      return iter.isSubset(this);\n    },\n\n    keyOf: function keyOf(searchValue) {\n      return this.findKey(function (value) { return is(value, searchValue); });\n    },\n\n    keySeq: function keySeq() {\n      return this.toSeq().map(keyMapper).toIndexedSeq();\n    },\n\n    last: function last(notSetValue) {\n      return this.toSeq().reverse().first(notSetValue);\n    },\n\n    lastKeyOf: function lastKeyOf(searchValue) {\n      return this.toKeyedSeq().reverse().keyOf(searchValue);\n    },\n\n    max: function max(comparator) {\n      return maxFactory(this, comparator);\n    },\n\n    maxBy: function maxBy(mapper, comparator) {\n      return maxFactory(this, comparator, mapper);\n    },\n\n    min: function min(comparator) {\n      return maxFactory(\n        this,\n        comparator ? neg(comparator) : defaultNegComparator\n      );\n    },\n\n    minBy: function minBy(mapper, comparator) {\n      return maxFactory(\n        this,\n        comparator ? neg(comparator) : defaultNegComparator,\n        mapper\n      );\n    },\n\n    rest: function rest() {\n      return this.slice(1);\n    },\n\n    skip: function skip(amount) {\n      return amount === 0 ? this : this.slice(Math.max(0, amount));\n    },\n\n    skipLast: function skipLast(amount) {\n      return amount === 0 ? this : this.slice(0, -Math.max(0, amount));\n    },\n\n    skipWhile: function skipWhile(predicate, context) {\n      return reify(this, skipWhileFactory(this, predicate, context, true));\n    },\n\n    skipUntil: function skipUntil(predicate, context) {\n      return this.skipWhile(not(predicate), context);\n    },\n\n    sortBy: function sortBy(mapper, comparator) {\n      return reify(this, sortFactory(this, comparator, mapper));\n    },\n\n    take: function take(amount) {\n      return this.slice(0, Math.max(0, amount));\n    },\n\n    takeLast: function takeLast(amount) {\n      return this.slice(-Math.max(0, amount));\n    },\n\n    takeWhile: function takeWhile(predicate, context) {\n      return reify(this, takeWhileFactory(this, predicate, context));\n    },\n\n    takeUntil: function takeUntil(predicate, context) {\n      return this.takeWhile(not(predicate), context);\n    },\n\n    update: function update(fn) {\n      return fn(this);\n    },\n\n    valueSeq: function valueSeq() {\n      return this.toIndexedSeq();\n    },\n\n    // ### Hashable Object\n\n    hashCode: function hashCode() {\n      return this.__hash || (this.__hash = hashCollection(this));\n    },\n\n    // ### Internal\n\n    // abstract __iterate(fn, reverse)\n\n    // abstract __iterator(type, reverse)\n  });\n\n  var CollectionPrototype = Collection.prototype;\n  CollectionPrototype[IS_COLLECTION_SYMBOL] = true;\n  CollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.values;\n  CollectionPrototype.toJSON = CollectionPrototype.toArray;\n  CollectionPrototype.__toStringMapper = quoteString;\n  CollectionPrototype.inspect = CollectionPrototype.toSource = function () {\n    return this.toString();\n  };\n  CollectionPrototype.chain = CollectionPrototype.flatMap;\n  CollectionPrototype.contains = CollectionPrototype.includes;\n\n  mixin(KeyedCollection, {\n    // ### More sequential methods\n\n    flip: function flip() {\n      return reify(this, flipFactory(this));\n    },\n\n    mapEntries: function mapEntries(mapper, context) {\n      var this$1$1 = this;\n\n      var iterations = 0;\n      return reify(\n        this,\n        this.toSeq()\n          .map(function (v, k) { return mapper.call(context, [k, v], iterations++, this$1$1); })\n          .fromEntrySeq()\n      );\n    },\n\n    mapKeys: function mapKeys(mapper, context) {\n      var this$1$1 = this;\n\n      return reify(\n        this,\n        this.toSeq()\n          .flip()\n          .map(function (k, v) { return mapper.call(context, k, v, this$1$1); })\n          .flip()\n      );\n    },\n  });\n\n  var KeyedCollectionPrototype = KeyedCollection.prototype;\n  KeyedCollectionPrototype[IS_KEYED_SYMBOL] = true;\n  KeyedCollectionPrototype[ITERATOR_SYMBOL] = CollectionPrototype.entries;\n  KeyedCollectionPrototype.toJSON = toObject;\n  KeyedCollectionPrototype.__toStringMapper = function (v, k) { return quoteString(k) + ': ' + quoteString(v); };\n\n  mixin(IndexedCollection, {\n    // ### Conversion to other types\n\n    toKeyedSeq: function toKeyedSeq() {\n      return new ToKeyedSequence(this, false);\n    },\n\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    filter: function filter(predicate, context) {\n      return reify(this, filterFactory(this, predicate, context, false));\n    },\n\n    findIndex: function findIndex(predicate, context) {\n      var entry = this.findEntry(predicate, context);\n      return entry ? entry[0] : -1;\n    },\n\n    indexOf: function indexOf(searchValue) {\n      var key = this.keyOf(searchValue);\n      return key === undefined ? -1 : key;\n    },\n\n    lastIndexOf: function lastIndexOf(searchValue) {\n      var key = this.lastKeyOf(searchValue);\n      return key === undefined ? -1 : key;\n    },\n\n    reverse: function reverse() {\n      return reify(this, reverseFactory(this, false));\n    },\n\n    slice: function slice(begin, end) {\n      return reify(this, sliceFactory(this, begin, end, false));\n    },\n\n    splice: function splice(index, removeNum /*, ...values*/) {\n      var numArgs = arguments.length;\n      removeNum = Math.max(removeNum || 0, 0);\n      if (numArgs === 0 || (numArgs === 2 && !removeNum)) {\n        return this;\n      }\n      // If index is negative, it should resolve relative to the size of the\n      // collection. However size may be expensive to compute if not cached, so\n      // only call count() if the number is in fact negative.\n      index = resolveBegin(index, index < 0 ? this.count() : this.size);\n      var spliced = this.slice(0, index);\n      return reify(\n        this,\n        numArgs === 1\n          ? spliced\n          : spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum))\n      );\n    },\n\n    // ### More collection methods\n\n    findLastIndex: function findLastIndex(predicate, context) {\n      var entry = this.findLastEntry(predicate, context);\n      return entry ? entry[0] : -1;\n    },\n\n    first: function first(notSetValue) {\n      return this.get(0, notSetValue);\n    },\n\n    flatten: function flatten(depth) {\n      return reify(this, flattenFactory(this, depth, false));\n    },\n\n    get: function get(index, notSetValue) {\n      index = wrapIndex(this, index);\n      return index < 0 ||\n        this.size === Infinity ||\n        (this.size !== undefined && index > this.size)\n        ? notSetValue\n        : this.find(function (_, key) { return key === index; }, undefined, notSetValue);\n    },\n\n    has: function has(index) {\n      index = wrapIndex(this, index);\n      return (\n        index >= 0 &&\n        (this.size !== undefined\n          ? this.size === Infinity || index < this.size\n          : this.indexOf(index) !== -1)\n      );\n    },\n\n    interpose: function interpose(separator) {\n      return reify(this, interposeFactory(this, separator));\n    },\n\n    interleave: function interleave(/*...collections*/) {\n      var collections = [this].concat(arrCopy(arguments));\n      var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, collections);\n      var interleaved = zipped.flatten(true);\n      if (zipped.size) {\n        interleaved.size = zipped.size * collections.length;\n      }\n      return reify(this, interleaved);\n    },\n\n    keySeq: function keySeq() {\n      return Range(0, this.size);\n    },\n\n    last: function last(notSetValue) {\n      return this.get(-1, notSetValue);\n    },\n\n    skipWhile: function skipWhile(predicate, context) {\n      return reify(this, skipWhileFactory(this, predicate, context, false));\n    },\n\n    zip: function zip(/*, ...collections */) {\n      var collections = [this].concat(arrCopy(arguments));\n      return reify(this, zipWithFactory(this, defaultZipper, collections));\n    },\n\n    zipAll: function zipAll(/*, ...collections */) {\n      var collections = [this].concat(arrCopy(arguments));\n      return reify(this, zipWithFactory(this, defaultZipper, collections, true));\n    },\n\n    zipWith: function zipWith(zipper /*, ...collections */) {\n      var collections = arrCopy(arguments);\n      collections[0] = this;\n      return reify(this, zipWithFactory(this, zipper, collections));\n    },\n  });\n\n  var IndexedCollectionPrototype = IndexedCollection.prototype;\n  IndexedCollectionPrototype[IS_INDEXED_SYMBOL] = true;\n  IndexedCollectionPrototype[IS_ORDERED_SYMBOL] = true;\n\n  mixin(SetCollection, {\n    // ### ES6 Collection methods (ES6 Array and Map)\n\n    get: function get(value, notSetValue) {\n      return this.has(value) ? value : notSetValue;\n    },\n\n    includes: function includes(value) {\n      return this.has(value);\n    },\n\n    // ### More sequential methods\n\n    keySeq: function keySeq() {\n      return this.valueSeq();\n    },\n  });\n\n  var SetCollectionPrototype = SetCollection.prototype;\n  SetCollectionPrototype.has = CollectionPrototype.includes;\n  SetCollectionPrototype.contains = SetCollectionPrototype.includes;\n  SetCollectionPrototype.keys = SetCollectionPrototype.values;\n\n  // Mixin subclasses\n\n  mixin(KeyedSeq, KeyedCollectionPrototype);\n  mixin(IndexedSeq, IndexedCollectionPrototype);\n  mixin(SetSeq, SetCollectionPrototype);\n\n  // #pragma Helper functions\n\n  function reduce(collection, reducer, reduction, context, useFirst, reverse) {\n    assertNotInfinite(collection.size);\n    collection.__iterate(function (v, k, c) {\n      if (useFirst) {\n        useFirst = false;\n        reduction = v;\n      } else {\n        reduction = reducer.call(context, reduction, v, k, c);\n      }\n    }, reverse);\n    return reduction;\n  }\n\n  function keyMapper(v, k) {\n    return k;\n  }\n\n  function entryMapper(v, k) {\n    return [k, v];\n  }\n\n  function not(predicate) {\n    return function () {\n      return !predicate.apply(this, arguments);\n    };\n  }\n\n  function neg(predicate) {\n    return function () {\n      return -predicate.apply(this, arguments);\n    };\n  }\n\n  function defaultZipper() {\n    return arrCopy(arguments);\n  }\n\n  function defaultNegComparator(a, b) {\n    return a < b ? 1 : a > b ? -1 : 0;\n  }\n\n  function hashCollection(collection) {\n    if (collection.size === Infinity) {\n      return 0;\n    }\n    var ordered = isOrdered(collection);\n    var keyed = isKeyed(collection);\n    var h = ordered ? 1 : 0;\n    var size = collection.__iterate(\n      keyed\n        ? ordered\n          ? function (v, k) {\n              h = (31 * h + hashMerge(hash(v), hash(k))) | 0;\n            }\n          : function (v, k) {\n              h = (h + hashMerge(hash(v), hash(k))) | 0;\n            }\n        : ordered\n        ? function (v) {\n            h = (31 * h + hash(v)) | 0;\n          }\n        : function (v) {\n            h = (h + hash(v)) | 0;\n          }\n    );\n    return murmurHashOfSize(size, h);\n  }\n\n  function murmurHashOfSize(size, h) {\n    h = imul(h, 0xcc9e2d51);\n    h = imul((h << 15) | (h >>> -15), 0x1b873593);\n    h = imul((h << 13) | (h >>> -13), 5);\n    h = ((h + 0xe6546b64) | 0) ^ size;\n    h = imul(h ^ (h >>> 16), 0x85ebca6b);\n    h = imul(h ^ (h >>> 13), 0xc2b2ae35);\n    h = smi(h ^ (h >>> 16));\n    return h;\n  }\n\n  function hashMerge(a, b) {\n    return (a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2))) | 0; // int\n  }\n\n  var OrderedSet = /*@__PURE__*/(function (Set) {\n    function OrderedSet(value) {\n      return value === undefined || value === null\n        ? emptyOrderedSet()\n        : isOrderedSet(value)\n        ? value\n        : emptyOrderedSet().withMutations(function (set) {\n            var iter = SetCollection(value);\n            assertNotInfinite(iter.size);\n            iter.forEach(function (v) { return set.add(v); });\n          });\n    }\n\n    if ( Set ) OrderedSet.__proto__ = Set;\n    OrderedSet.prototype = Object.create( Set && Set.prototype );\n    OrderedSet.prototype.constructor = OrderedSet;\n\n    OrderedSet.of = function of (/*...values*/) {\n      return this(arguments);\n    };\n\n    OrderedSet.fromKeys = function fromKeys (value) {\n      return this(KeyedCollection(value).keySeq());\n    };\n\n    OrderedSet.prototype.toString = function toString () {\n      return this.__toString('OrderedSet {', '}');\n    };\n\n    return OrderedSet;\n  }(Set));\n\n  OrderedSet.isOrderedSet = isOrderedSet;\n\n  var OrderedSetPrototype = OrderedSet.prototype;\n  OrderedSetPrototype[IS_ORDERED_SYMBOL] = true;\n  OrderedSetPrototype.zip = IndexedCollectionPrototype.zip;\n  OrderedSetPrototype.zipWith = IndexedCollectionPrototype.zipWith;\n  OrderedSetPrototype.zipAll = IndexedCollectionPrototype.zipAll;\n\n  OrderedSetPrototype.__empty = emptyOrderedSet;\n  OrderedSetPrototype.__make = makeOrderedSet;\n\n  function makeOrderedSet(map, ownerID) {\n    var set = Object.create(OrderedSetPrototype);\n    set.size = map ? map.size : 0;\n    set._map = map;\n    set.__ownerID = ownerID;\n    return set;\n  }\n\n  var EMPTY_ORDERED_SET;\n  function emptyOrderedSet() {\n    return (\n      EMPTY_ORDERED_SET || (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()))\n    );\n  }\n\n  function throwOnInvalidDefaultValues(defaultValues) {\n    if (isRecord(defaultValues)) {\n      throw new Error(\n        'Can not call `Record` with an immutable Record as default values. Use a plain javascript object instead.'\n      );\n    }\n\n    if (isImmutable(defaultValues)) {\n      throw new Error(\n        'Can not call `Record` with an immutable Collection as default values. Use a plain javascript object instead.'\n      );\n    }\n\n    if (defaultValues === null || typeof defaultValues !== 'object') {\n      throw new Error(\n        'Can not call `Record` with a non-object as default values. Use a plain javascript object instead.'\n      );\n    }\n  }\n\n  var Record = function Record(defaultValues, name) {\n    var hasInitialized;\n\n    throwOnInvalidDefaultValues(defaultValues);\n\n    var RecordType = function Record(values) {\n      var this$1$1 = this;\n\n      if (values instanceof RecordType) {\n        return values;\n      }\n      if (!(this instanceof RecordType)) {\n        return new RecordType(values);\n      }\n      if (!hasInitialized) {\n        hasInitialized = true;\n        var keys = Object.keys(defaultValues);\n        var indices = (RecordTypePrototype._indices = {});\n        // Deprecated: left to attempt not to break any external code which\n        // relies on a ._name property existing on record instances.\n        // Use Record.getDescriptiveName() instead\n        RecordTypePrototype._name = name;\n        RecordTypePrototype._keys = keys;\n        RecordTypePrototype._defaultValues = defaultValues;\n        for (var i = 0; i < keys.length; i++) {\n          var propName = keys[i];\n          indices[propName] = i;\n          if (RecordTypePrototype[propName]) {\n            /* eslint-disable no-console */\n            typeof console === 'object' &&\n              console.warn &&\n              console.warn(\n                'Cannot define ' +\n                  recordName(this) +\n                  ' with property \"' +\n                  propName +\n                  '\" since that property name is part of the Record API.'\n              );\n            /* eslint-enable no-console */\n          } else {\n            setProp(RecordTypePrototype, propName);\n          }\n        }\n      }\n      this.__ownerID = undefined;\n      this._values = List().withMutations(function (l) {\n        l.setSize(this$1$1._keys.length);\n        KeyedCollection(values).forEach(function (v, k) {\n          l.set(this$1$1._indices[k], v === this$1$1._defaultValues[k] ? undefined : v);\n        });\n      });\n      return this;\n    };\n\n    var RecordTypePrototype = (RecordType.prototype =\n      Object.create(RecordPrototype));\n    RecordTypePrototype.constructor = RecordType;\n\n    if (name) {\n      RecordType.displayName = name;\n    }\n\n    return RecordType;\n  };\n\n  Record.prototype.toString = function toString () {\n    var str = recordName(this) + ' { ';\n    var keys = this._keys;\n    var k;\n    for (var i = 0, l = keys.length; i !== l; i++) {\n      k = keys[i];\n      str += (i ? ', ' : '') + k + ': ' + quoteString(this.get(k));\n    }\n    return str + ' }';\n  };\n\n  Record.prototype.equals = function equals (other) {\n    return (\n      this === other ||\n      (isRecord(other) && recordSeq(this).equals(recordSeq(other)))\n    );\n  };\n\n  Record.prototype.hashCode = function hashCode () {\n    return recordSeq(this).hashCode();\n  };\n\n  // @pragma Access\n\n  Record.prototype.has = function has (k) {\n    return this._indices.hasOwnProperty(k);\n  };\n\n  Record.prototype.get = function get (k, notSetValue) {\n    if (!this.has(k)) {\n      return notSetValue;\n    }\n    var index = this._indices[k];\n    var value = this._values.get(index);\n    return value === undefined ? this._defaultValues[k] : value;\n  };\n\n  // @pragma Modification\n\n  Record.prototype.set = function set (k, v) {\n    if (this.has(k)) {\n      var newValues = this._values.set(\n        this._indices[k],\n        v === this._defaultValues[k] ? undefined : v\n      );\n      if (newValues !== this._values && !this.__ownerID) {\n        return makeRecord(this, newValues);\n      }\n    }\n    return this;\n  };\n\n  Record.prototype.remove = function remove (k) {\n    return this.set(k);\n  };\n\n  Record.prototype.clear = function clear () {\n    var newValues = this._values.clear().setSize(this._keys.length);\n\n    return this.__ownerID ? this : makeRecord(this, newValues);\n  };\n\n  Record.prototype.wasAltered = function wasAltered () {\n    return this._values.wasAltered();\n  };\n\n  Record.prototype.toSeq = function toSeq () {\n    return recordSeq(this);\n  };\n\n  Record.prototype.toJS = function toJS$1 () {\n    return toJS(this);\n  };\n\n  Record.prototype.entries = function entries () {\n    return this.__iterator(ITERATE_ENTRIES);\n  };\n\n  Record.prototype.__iterator = function __iterator (type, reverse) {\n    return recordSeq(this).__iterator(type, reverse);\n  };\n\n  Record.prototype.__iterate = function __iterate (fn, reverse) {\n    return recordSeq(this).__iterate(fn, reverse);\n  };\n\n  Record.prototype.__ensureOwner = function __ensureOwner (ownerID) {\n    if (ownerID === this.__ownerID) {\n      return this;\n    }\n    var newValues = this._values.__ensureOwner(ownerID);\n    if (!ownerID) {\n      this.__ownerID = ownerID;\n      this._values = newValues;\n      return this;\n    }\n    return makeRecord(this, newValues, ownerID);\n  };\n\n  Record.isRecord = isRecord;\n  Record.getDescriptiveName = recordName;\n  var RecordPrototype = Record.prototype;\n  RecordPrototype[IS_RECORD_SYMBOL] = true;\n  RecordPrototype[DELETE] = RecordPrototype.remove;\n  RecordPrototype.deleteIn = RecordPrototype.removeIn = deleteIn;\n  RecordPrototype.getIn = getIn;\n  RecordPrototype.hasIn = CollectionPrototype.hasIn;\n  RecordPrototype.merge = merge$1;\n  RecordPrototype.mergeWith = mergeWith$1;\n  RecordPrototype.mergeIn = mergeIn;\n  RecordPrototype.mergeDeep = mergeDeep;\n  RecordPrototype.mergeDeepWith = mergeDeepWith;\n  RecordPrototype.mergeDeepIn = mergeDeepIn;\n  RecordPrototype.setIn = setIn;\n  RecordPrototype.update = update;\n  RecordPrototype.updateIn = updateIn;\n  RecordPrototype.withMutations = withMutations;\n  RecordPrototype.asMutable = asMutable;\n  RecordPrototype.asImmutable = asImmutable;\n  RecordPrototype[ITERATOR_SYMBOL] = RecordPrototype.entries;\n  RecordPrototype.toJSON = RecordPrototype.toObject =\n    CollectionPrototype.toObject;\n  RecordPrototype.inspect = RecordPrototype.toSource = function () {\n    return this.toString();\n  };\n\n  function makeRecord(likeRecord, values, ownerID) {\n    var record = Object.create(Object.getPrototypeOf(likeRecord));\n    record._values = values;\n    record.__ownerID = ownerID;\n    return record;\n  }\n\n  function recordName(record) {\n    return record.constructor.displayName || record.constructor.name || 'Record';\n  }\n\n  function recordSeq(record) {\n    return keyedSeqFromValue(record._keys.map(function (k) { return [k, record.get(k)]; }));\n  }\n\n  function setProp(prototype, name) {\n    try {\n      Object.defineProperty(prototype, name, {\n        get: function () {\n          return this.get(name);\n        },\n        set: function (value) {\n          invariant(this.__ownerID, 'Cannot set on an immutable record.');\n          this.set(name, value);\n        },\n      });\n    } catch (error) {\n      // Object.defineProperty failed. Probably IE8.\n    }\n  }\n\n  /**\n   * Returns a lazy Seq of `value` repeated `times` times. When `times` is\n   * undefined, returns an infinite sequence of `value`.\n   */\n  var Repeat = /*@__PURE__*/(function (IndexedSeq) {\n    function Repeat(value, times) {\n      if (!(this instanceof Repeat)) {\n        return new Repeat(value, times);\n      }\n      this._value = value;\n      this.size = times === undefined ? Infinity : Math.max(0, times);\n      if (this.size === 0) {\n        if (EMPTY_REPEAT) {\n          return EMPTY_REPEAT;\n        }\n        EMPTY_REPEAT = this;\n      }\n    }\n\n    if ( IndexedSeq ) Repeat.__proto__ = IndexedSeq;\n    Repeat.prototype = Object.create( IndexedSeq && IndexedSeq.prototype );\n    Repeat.prototype.constructor = Repeat;\n\n    Repeat.prototype.toString = function toString () {\n      if (this.size === 0) {\n        return 'Repeat []';\n      }\n      return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]';\n    };\n\n    Repeat.prototype.get = function get (index, notSetValue) {\n      return this.has(index) ? this._value : notSetValue;\n    };\n\n    Repeat.prototype.includes = function includes (searchValue) {\n      return is(this._value, searchValue);\n    };\n\n    Repeat.prototype.slice = function slice (begin, end) {\n      var size = this.size;\n      return wholeSlice(begin, end, size)\n        ? this\n        : new Repeat(\n            this._value,\n            resolveEnd(end, size) - resolveBegin(begin, size)\n          );\n    };\n\n    Repeat.prototype.reverse = function reverse () {\n      return this;\n    };\n\n    Repeat.prototype.indexOf = function indexOf (searchValue) {\n      if (is(this._value, searchValue)) {\n        return 0;\n      }\n      return -1;\n    };\n\n    Repeat.prototype.lastIndexOf = function lastIndexOf (searchValue) {\n      if (is(this._value, searchValue)) {\n        return this.size;\n      }\n      return -1;\n    };\n\n    Repeat.prototype.__iterate = function __iterate (fn, reverse) {\n      var size = this.size;\n      var i = 0;\n      while (i !== size) {\n        if (fn(this._value, reverse ? size - ++i : i++, this) === false) {\n          break;\n        }\n      }\n      return i;\n    };\n\n    Repeat.prototype.__iterator = function __iterator (type, reverse) {\n      var this$1$1 = this;\n\n      var size = this.size;\n      var i = 0;\n      return new Iterator(function () { return i === size\n          ? iteratorDone()\n          : iteratorValue(type, reverse ? size - ++i : i++, this$1$1._value); }\n      );\n    };\n\n    Repeat.prototype.equals = function equals (other) {\n      return other instanceof Repeat\n        ? is(this._value, other._value)\n        : deepEqual(other);\n    };\n\n    return Repeat;\n  }(IndexedSeq));\n\n  var EMPTY_REPEAT;\n\n  function fromJS(value, converter) {\n    return fromJSWith(\n      [],\n      converter || defaultConverter,\n      value,\n      '',\n      converter && converter.length > 2 ? [] : undefined,\n      { '': value }\n    );\n  }\n\n  function fromJSWith(stack, converter, value, key, keyPath, parentValue) {\n    if (\n      typeof value !== 'string' &&\n      !isImmutable(value) &&\n      (isArrayLike(value) || hasIterator(value) || isPlainObject(value))\n    ) {\n      if (~stack.indexOf(value)) {\n        throw new TypeError('Cannot convert circular structure to Immutable');\n      }\n      stack.push(value);\n      keyPath && key !== '' && keyPath.push(key);\n      var converted = converter.call(\n        parentValue,\n        key,\n        Seq(value).map(function (v, k) { return fromJSWith(stack, converter, v, k, keyPath, value); }\n        ),\n        keyPath && keyPath.slice()\n      );\n      stack.pop();\n      keyPath && keyPath.pop();\n      return converted;\n    }\n    return value;\n  }\n\n  function defaultConverter(k, v) {\n    // Effectively the opposite of \"Collection.toSeq()\"\n    return isIndexed(v) ? v.toList() : isKeyed(v) ? v.toMap() : v.toSet();\n  }\n\n  var version = \"4.1.0\";\n\n  var Immutable = {\n    version: version,\n\n    Collection: Collection,\n    // Note: Iterable is deprecated\n    Iterable: Collection,\n\n    Seq: Seq,\n    Map: Map,\n    OrderedMap: OrderedMap,\n    List: List,\n    Stack: Stack,\n    Set: Set,\n    OrderedSet: OrderedSet,\n\n    Record: Record,\n    Range: Range,\n    Repeat: Repeat,\n\n    is: is,\n    fromJS: fromJS,\n    hash: hash,\n\n    isImmutable: isImmutable,\n    isCollection: isCollection,\n    isKeyed: isKeyed,\n    isIndexed: isIndexed,\n    isAssociative: isAssociative,\n    isOrdered: isOrdered,\n    isValueObject: isValueObject,\n    isPlainObject: isPlainObject,\n    isSeq: isSeq,\n    isList: isList,\n    isMap: isMap,\n    isOrderedMap: isOrderedMap,\n    isStack: isStack,\n    isSet: isSet,\n    isOrderedSet: isOrderedSet,\n    isRecord: isRecord,\n\n    get: get,\n    getIn: getIn$1,\n    has: has,\n    hasIn: hasIn$1,\n    merge: merge,\n    mergeDeep: mergeDeep$1,\n    mergeWith: mergeWith,\n    mergeDeepWith: mergeDeepWith$1,\n    remove: remove,\n    removeIn: removeIn,\n    set: set,\n    setIn: setIn$1,\n    update: update$1,\n    updateIn: updateIn$1,\n  };\n\n  // Note: Iterable is deprecated\n  var Iterable = Collection;\n\n  exports.Collection = Collection;\n  exports.Iterable = Iterable;\n  exports.List = List;\n  exports.Map = Map;\n  exports.OrderedMap = OrderedMap;\n  exports.OrderedSet = OrderedSet;\n  exports.Range = Range;\n  exports.Record = Record;\n  exports.Repeat = Repeat;\n  exports.Seq = Seq;\n  exports.Set = Set;\n  exports.Stack = Stack;\n  exports.default = Immutable;\n  exports.fromJS = fromJS;\n  exports.get = get;\n  exports.getIn = getIn$1;\n  exports.has = has;\n  exports.hasIn = hasIn$1;\n  exports.hash = hash;\n  exports.is = is;\n  exports.isAssociative = isAssociative;\n  exports.isCollection = isCollection;\n  exports.isImmutable = isImmutable;\n  exports.isIndexed = isIndexed;\n  exports.isKeyed = isKeyed;\n  exports.isList = isList;\n  exports.isMap = isMap;\n  exports.isOrdered = isOrdered;\n  exports.isOrderedMap = isOrderedMap;\n  exports.isOrderedSet = isOrderedSet;\n  exports.isPlainObject = isPlainObject;\n  exports.isRecord = isRecord;\n  exports.isSeq = isSeq;\n  exports.isSet = isSet;\n  exports.isStack = isStack;\n  exports.isValueObject = isValueObject;\n  exports.merge = merge;\n  exports.mergeDeep = mergeDeep$1;\n  exports.mergeDeepWith = mergeDeepWith$1;\n  exports.mergeWith = mergeWith;\n  exports.remove = remove;\n  exports.removeIn = removeIn;\n  exports.set = set;\n  exports.setIn = setIn$1;\n  exports.update = update$1;\n  exports.updateIn = updateIn$1;\n  exports.version = version;\n\n  Object.defineProperty(exports, '__esModule', { value: true });\n\n})));\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n","module.exports = require('../impls/$append/append.js').__append;","module.exports = require('../impls/apply/apply.js').__apply;","module.exports = require('../impls/array-reverse/array-reverse.js').__arrayReverse;","module.exports = require('../impls/$append/async-append.js').__asyncAppend;","module.exports = require('../impls/$batch/async-batch.js').__asyncBatch;","module.exports = require('../impls/$bisect/async-bisect.js').__asyncBisect;","module.exports = require('../impls/async-buffer/async-buffer.js').__asyncBuffer;","module.exports = require('../impls/$collate/async-collate.js').__asyncCollate;","module.exports = require('../impls/$compress/async-compress.js').__asyncCompress;","module.exports = require('../impls/$concat/async-concat.js').__asyncConcat;","module.exports = require('../impls/$consume/async-consume.js').__asyncConsume;","module.exports = require('../impls/$cycle-times/async-cycle-times.js').__asyncCycleTimes;","module.exports = require('../impls/$cycle/async-cycle.js').__asyncCycle;","module.exports = require('../impls/$deep-equal/async-deep-equal.js').__asyncDeepEqual;","module.exports = require('../impls/$distinct/async-distinct.js').__asyncDistinct;","module.exports = require('../impls/$drop-while/async-drop-while.js').__asyncDropWhile;","module.exports = require('../impls/$drop/async-drop.js').__asyncDrop;","module.exports = require('../impls/$enumerate/async-enumerate.js').__asyncEnumerate;","module.exports = require('../impls/$equal/async-equal.js').__asyncEqual;","module.exports = require('../impls/$every/async-every.js').__asyncEvery;","module.exports = require('../impls/$filter/async-filter.js').__asyncFilter;","module.exports = require('../impls/$find-best-or/async-find-best-or.js').__asyncFindBestOr;","module.exports = require('../impls/$find-best/async-find-best.js').__asyncFindBest;","module.exports = require('../impls/$find-or/async-find-or.js').__asyncFindOr;","module.exports = require('../impls/$find/async-find.js').__asyncFind;","module.exports = require('../impls/$first-or/async-first-or.js').__asyncFirstOr;","module.exports = require('../impls/$first/async-first.js').__asyncFirst;","module.exports = require('../impls/$flat-map/async-flat-map.js').__asyncFlatMap;","module.exports = require('../impls/$flat/async-flat.js').__asyncFlat;","module.exports = require('../impls/$for-each/async-for-each.js').__asyncForEach;","module.exports = require('../impls/$fork/async-fork.js').__asyncFork;","module.exports = require('../impls/$forkerate/async-forkerate.js').__asyncForkerate;","module.exports = require('../impls/$includes-any-seq/async-includes-any-seq.js').__asyncIncludesAnySeq;","module.exports = require('../impls/$includes-any/async-includes-any.js').__asyncIncludesAny;","module.exports = require('../impls/$includes-seq/async-includes-seq.js').__asyncIncludesSeq;","module.exports = require('../impls/$includes/async-includes.js').__asyncIncludes;","module.exports = require('../impls/async-interleave-ready/async-interleave-ready.js').__asyncInterleaveReady;","module.exports = require('../impls/$interleave/async-interleave.js').__asyncInterleave;","module.exports = require('../impls/$interpose-seq/async-interpose-seq.js').__asyncInterposeSeq;","module.exports = require('../impls/$interpose/async-interpose.js').__asyncInterpose;","module.exports = require('../impls/$is-empty/async-is-empty.js').__asyncIsEmpty;","module.exports = require('../impls/$is-sorted/async-is-sorted.js').__asyncIsSorted;","module.exports = require('../impls/$join-with-seq/async-join-with-seq.js').__asyncJoinWithSeq;","module.exports = require('../impls/$join-with/async-join-with.js').__asyncJoinWith;","module.exports = require('../impls/$join/async-join.js').__asyncJoin;","module.exports = require('../impls/$map/async-map.js').__asyncMap;","module.exports = require('../impls/$peekerate/async-peekerate.js').__asyncPeekerate;","module.exports = require('../impls/$prepend/async-prepend.js').__asyncPrepend;","module.exports = require('../impls/$reduce/async-reduce.js').__asyncReduce;","module.exports = require('../impls/$reverse/async-reverse.js').__asyncReverse;","module.exports = require('../impls/$round-robin/async-round-robin.js').__asyncRoundRobin;","module.exports = require('../impls/$size/async-size.js').__asyncSize;","module.exports = require('../impls/$slice/async-slice.js').__asyncSliceFromStart;","module.exports = require('../impls/$some/async-some.js').__asyncSome;","module.exports = require('../impls/$split-groups/async-split-groups.js').__asyncSplitGroups;","module.exports = require('../impls/$split-on-any-seq/async-split-on-any-seq.js').__asyncSplitOnAnySeq;","module.exports = require('../impls/$split-on-any/async-split-on-any.js').__asyncSplitOnAny;","module.exports = require('../impls/$split-on-seq/async-split-on-seq.js').__asyncSplitOnSeq;","module.exports = require('../impls/$split-on/async-split-on.js').__asyncSplitOn;","module.exports = require('../impls/$split-when/async-split-when.js').__asyncSplitWhen;","module.exports = require('../impls/$split/async-split.js').__asyncSplit;","module.exports = require('../impls/$spliterate-grouped/async-spliterate-grouped.js').__asyncSpliterateGrouped;","module.exports = require('../impls/$spliterate/async-spliterate.js').__asyncSpliterate;","module.exports = require('../impls/$starts-with-any-seq/async-starts-with-any-seq.js').__asyncStartsWithAnySeq;","module.exports = require('../impls/$starts-with-any/async-starts-with-any.js').__asyncStartsWithAny;","module.exports = require('../impls/$starts-with-seq/async-starts-with-seq.js').__asyncStartsWithSeq;","module.exports = require('../impls/$starts-with/async-starts-with.js').__asyncStartsWith;","module.exports = require('../impls/$str/async-str.js').__asyncStr;","module.exports = require('../impls/$take-last-or/async-take-last-or.js').__asyncTakeLastOr;","module.exports = require('../impls/$take-last/async-take-last.js').__asyncTakeLast;","module.exports = require('../impls/$take-sorted/async-take-sorted.js').__asyncTakeSorted;","module.exports = require('../impls/$take-while/async-take-while.js').__asyncTakeWhile;","module.exports = require('../impls/$take/async-take.js').__asyncTake;","module.exports = require('../impls/$tap/async-tap.js').__asyncTap;","module.exports = require('../impls/async-throttle/async-throttle.js').__asyncThrottle;","module.exports = require('../impls/$to-array/async-to-array.js').__asyncToArray;","module.exports = require('../impls/$to-object/async-to-object.js').__asyncToObject;","module.exports = require('../impls/$window-ahead/async-window-ahead.js').__asyncWindowAhead;","module.exports = require('../impls/$window-behind/async-window-behind.js').__asyncWindowBehind;","module.exports = require('../impls/$window/async-window.js').__asyncWindow;","module.exports = require('../impls/$zip-all/async-zip-all.js').__asyncZipAll;","module.exports = require('../impls/$zip/async-zip.js').__asyncZip;","module.exports = require('../impls/$batch/batch.js').__batch;","module.exports = require('../impls/$bisect/bisect.js').__bisect;","module.exports = require('../impls/call/call.js').__call;","module.exports = require('../impls/$collate/collate.js').__collate;","module.exports = require('../impls/$compress/compress.js').__compress;","module.exports = require('../impls/$concat/concat.js').__concat;","module.exports = require('../impls/$consume/consume.js').__consume;","module.exports = require('../impls/$cycle-times/cycle-times.js').__cycleTimes;","module.exports = require('../impls/$cycle/cycle.js').__cycle;","module.exports = require('../impls/$deep-equal/deep-equal.js').__deepEqual;","module.exports = require('../impls/$distinct/distinct.js').__distinct;","module.exports = require('../impls/$drop-while/drop-while.js').__dropWhile;","module.exports = require('../impls/$drop/drop.js').__drop;","module.exports = require('../impls/$enumerate/enumerate.js').__enumerate;","module.exports = require('../impls/$equal/equal.js').__equal;","module.exports = require('../impls/$every/every.js').__every;","module.exports = require('../impls/$filter/filter.js').__filter;","module.exports = require('../impls/$find-best-or/find-best-or.js').__findBestOr;","module.exports = require('../impls/$find-best/find-best.js').__findBest;","module.exports = require('../impls/$find-or/find-or.js').__findOr;","module.exports = require('../impls/$find/find.js').__find;","module.exports = require('../impls/$first-or/first-or.js').__firstOr;","module.exports = require('../impls/$first/first.js').__first;","module.exports = require('../impls/$flat-map/flat-map.js').__flatMap;","module.exports = require('../impls/$flat/flat.js').__flat;","module.exports = require('../impls/$for-each/for-each.js').__forEach;","module.exports = require('../impls/$fork/fork.js').__fork;","module.exports = require('../impls/$forkerate/forkerate.js').__forkerate;","module.exports = require('../impls/$includes-any-seq/includes-any-seq.js').__includesAnySeq;","module.exports = require('../impls/$includes-any/includes-any.js').__includesAny;","module.exports = require('../impls/$includes-seq/includes-seq.js').__includesSeq;","module.exports = require('../impls/$includes/includes.js').__includes;","module.exports = require('../impls/$interleave/interleave.js').__interleave;","module.exports = require('../impls/$interpose-seq/interpose-seq.js').__interposeSeq;","module.exports = require('../impls/$interpose/interpose.js').__interpose;","module.exports = require('../impls/$is-empty/is-empty.js').__isEmpty;","module.exports = require('../impls/$is-sorted/is-sorted.js').__isSorted;","module.exports = require('../impls/$join-with-seq/join-with-seq.js').__joinWithSeq;","module.exports = require('../impls/$join-with/join-with.js').__joinWith;","module.exports = require('../impls/$join/join.js').__join;","module.exports = require('../impls/$map/map.js').__map;","module.exports = require('../impls/object-entries/object-entries.js').__objectEntries;","module.exports = require('../impls/object-keys/object-keys.js').__objectKeys;","module.exports = require('../impls/object-values/object-values.js').__objectValues;","module.exports = require('../impls/$peekerate/peekerate.js').__peekerate;","module.exports = require('../impls/$prepend/prepend.js').__prepend;","module.exports = require('../impls/range/range.js').__range;","module.exports = require('../impls/$reduce/reduce.js').__reduce;","module.exports = require('../impls/repeat-times/repeat-times.js').__repeatTimes;","module.exports = require('../impls/repeat/repeat.js').__repeat;","module.exports = require('../impls/$reverse/reverse.js').__reverse;","module.exports = require('../impls/$round-robin/round-robin.js').__roundRobin;","module.exports = require('../impls/$size/size.js').__size;","module.exports = require('../impls/$slice/slice.js').__sliceFromStart;","module.exports = require('../impls/$some/some.js').__some;","module.exports = require('../impls/$split-groups/split-groups.js').__splitGroups;","module.exports = require('../impls/$split-on-any-seq/split-on-any-seq.js').__splitOnAnySeq;","module.exports = require('../impls/$split-on-any/split-on-any.js').__splitOnAny;","module.exports = require('../impls/$split-on-seq/split-on-seq.js').__splitOnSeq;","module.exports = require('../impls/$split-on/split-on.js').__splitOn;","module.exports = require('../impls/$split-when/split-when.js').__splitWhen;","module.exports = require('../impls/$split/split.js').__split;","module.exports = require('../impls/$spliterate-grouped/spliterate-grouped.js').__spliterateGrouped;","module.exports = require('../impls/$spliterate/spliterate.js').__spliterate;","module.exports = require('../impls/$starts-with-any-seq/starts-with-any-seq.js').__startsWithAnySeq;","module.exports = require('../impls/$starts-with-any/starts-with-any.js').__startsWithAny;","module.exports = require('../impls/$starts-with-seq/starts-with-seq.js').__startsWithSeq;","module.exports = require('../impls/$starts-with/starts-with.js').__startsWith;","module.exports = require('../impls/$str/str.js').__str;","module.exports = require('../impls/$take-last-or/take-last-or.js').__takeLastOr;","module.exports = require('../impls/$take-last/take-last.js').__takeLast;","module.exports = require('../impls/$take-sorted/take-sorted.js').__takeSorted;","module.exports = require('../impls/$take-while/take-while.js').__takeWhile;","module.exports = require('../impls/$take/take.js').__take;","module.exports = require('../impls/$tap/tap.js').__tap;","module.exports = require('../impls/$to-array/to-array.js').__toArray;","module.exports = require('../impls/$to-object/to-object.js').__toObject;","module.exports = require('../impls/$window-ahead/window-ahead.js').__windowAhead;","module.exports = require('../impls/$window-behind/window-behind.js').__windowBehind;","module.exports = require('../impls/$window/window.js').__window;","module.exports = require('../impls/wrap-entries/wrap-entries.js').__wrapEntries;","module.exports = require('../impls/wrap-keys/wrap-keys.js').__wrapKeys;","module.exports = require('../impls/wrap-values/wrap-values.js').__wrapValues;","module.exports = require('../impls/$zip-all/zip-all.js').__zipAll;","module.exports = require('../impls/$zip/zip.js').__zip;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__append);\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nfunction __append(source, value) {\n  return _regeneratorRuntime.wrap(function __append$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          return _context.delegateYield(source, \"t0\", 1);\n\n        case 1:\n          _context.next = 3;\n          return value;\n\n        case 3:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nexports.__append = __append;\nvar append = /*#__PURE__*/iterableCurry(__append);\nexports.append = append;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _asyncGeneratorDelegate = require(\"@babel/runtime/helpers/asyncGeneratorDelegate\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nfunction __asyncAppend(_x, _x2) {\n  return _asyncAppend.apply(this, arguments);\n}\n\nexports.__asyncAppend = __asyncAppend;\n\nfunction _asyncAppend() {\n  _asyncAppend = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, value) {\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(source), _awaitAsyncGenerator), \"t0\", 1);\n\n          case 1:\n            _context.next = 3;\n            return value;\n\n          case 3:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncAppend.apply(this, arguments);\n}\n\nvar asyncAppend = /*#__PURE__*/asyncIterableCurry(__asyncAppend);\nexports.asyncAppend = asyncAppend;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$spliterate/async-spliterate.js'),\n    __asyncSpliterate = _require2.__asyncSpliterate;\n\nfunction asyncBatchSpliterator(_x, _x2, _x3) {\n  return _asyncBatchSpliterator.apply(this, arguments);\n}\n\nfunction _asyncBatchSpliterator() {\n  _asyncBatchSpliterator = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(split, _ref, source) {\n    var size, i, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            size = _ref.size;\n            i = 0;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 4;\n            _iterator = _asyncIterator(source);\n\n          case 6:\n            _context.next = 8;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 8:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 12;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 12:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 25;\n              break;\n            }\n\n            value = _value;\n\n            if (!(i === size)) {\n              _context.next = 19;\n              break;\n            }\n\n            _context.next = 18;\n            return split;\n\n          case 18:\n            i = 0;\n\n          case 19:\n            _context.next = 21;\n            return value;\n\n          case 21:\n            i++;\n\n          case 22:\n            _iteratorNormalCompletion = true;\n            _context.next = 6;\n            break;\n\n          case 25:\n            _context.next = 31;\n            break;\n\n          case 27:\n            _context.prev = 27;\n            _context.t0 = _context[\"catch\"](4);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 31:\n            _context.prev = 31;\n            _context.prev = 32;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 36;\n              break;\n            }\n\n            _context.next = 36;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 36:\n            _context.prev = 36;\n\n            if (!_didIteratorError) {\n              _context.next = 39;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 39:\n            return _context.finish(36);\n\n          case 40:\n            return _context.finish(31);\n\n          case 41:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[4, 27, 31, 41], [32,, 36, 40]]);\n  }));\n  return _asyncBatchSpliterator.apply(this, arguments);\n}\n\nfunction __asyncBatch(source, size) {\n  return __asyncSpliterate(source, asyncBatchSpliterator, {\n    size: size\n  });\n}\n\nexports.__asyncBatch = __asyncBatch;\nvar asyncBatch = /*#__PURE__*/asyncIterableCurry(__asyncBatch, {\n  validateArgs: function validateArgs(args) {\n    if (typeof args[1] !== 'number' || args[1] < 1) {\n      throw new TypeError('batch size should be a number greater than zero');\n    }\n  }\n});\nexports.asyncBatch = asyncBatch;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(batchSpliterator);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$spliterate/spliterate.js'),\n    __spliterate = _require2.__spliterate;\n\nfunction batchSpliterator(split, _ref, source) {\n  var size, i, _iterator, _step, value;\n\n  return _regeneratorRuntime.wrap(function batchSpliterator$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          size = _ref.size;\n          i = 0;\n          _iterator = _createForOfIteratorHelper(source);\n          _context.prev = 3;\n\n          _iterator.s();\n\n        case 5:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 16;\n            break;\n          }\n\n          value = _step.value;\n\n          if (!(i === size)) {\n            _context.next = 11;\n            break;\n          }\n\n          _context.next = 10;\n          return split;\n\n        case 10:\n          i = 0;\n\n        case 11:\n          _context.next = 13;\n          return value;\n\n        case 13:\n          i++;\n\n        case 14:\n          _context.next = 5;\n          break;\n\n        case 16:\n          _context.next = 21;\n          break;\n\n        case 18:\n          _context.prev = 18;\n          _context.t0 = _context[\"catch\"](3);\n\n          _iterator.e(_context.t0);\n\n        case 21:\n          _context.prev = 21;\n\n          _iterator.f();\n\n          return _context.finish(21);\n\n        case 24:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[3, 18, 21, 24]]);\n}\n\nfunction __batch(source, size) {\n  return __spliterate(source, batchSpliterator, {\n    size: size\n  });\n}\n\nexports.__batch = __batch;\nvar batch = /*#__PURE__*/iterableCurry(__batch, {\n  validateArgs: function validateArgs(args) {\n    if (typeof args[1] !== 'number' || args[1] < 1) {\n      throw new TypeError('batch size should be a number greater than zero');\n    }\n  }\n});\nexports.batch = batch;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../../internal/async-bisector.js'),\n    AsyncBisector = _require2.AsyncBisector;\n\nvar _require3 = require('../$to-array/async-to-array.js'),\n    __asyncToArray = _require3.__asyncToArray;\n\nvar _require4 = require('../$peekerate/async-peekerate.js'),\n    __asyncPeekerate = _require4.__asyncPeekerate;\n\nfunction asyncIndexStrategy(_x, _x2, _x3) {\n  return _asyncIndexStrategy.apply(this, arguments);\n}\n\nexports.asyncIndexStrategy = asyncIndexStrategy;\n\nfunction _asyncIndexStrategy() {\n  _asyncIndexStrategy = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(split, _ref, source) {\n    var at, _source, idx, peekr;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            at = _ref.at;\n\n            if (!(at < 0)) {\n              _context.next = 7;\n              break;\n            }\n\n            _context.next = 4;\n            return _awaitAsyncGenerator(__asyncToArray(source));\n\n          case 4:\n            _context.t0 = _context.sent;\n            _context.next = 8;\n            break;\n\n          case 7:\n            _context.t0 = source;\n\n          case 8:\n            _source = _context.t0;\n            idx = at < 0 ? _source.length + at : at;\n            _context.next = 12;\n            return _awaitAsyncGenerator(__asyncPeekerate(_source));\n\n          case 12:\n            peekr = _context.sent;\n            _context.prev = 13;\n\n          case 14:\n            if (peekr.done) {\n              _context.next = 24;\n              break;\n            }\n\n            if (!(peekr.index === idx)) {\n              _context.next = 18;\n              break;\n            }\n\n            _context.next = 18;\n            return split;\n\n          case 18:\n            _context.next = 20;\n            return peekr.value;\n\n          case 20:\n            _context.next = 22;\n            return _awaitAsyncGenerator(peekr.advance());\n\n          case 22:\n            _context.next = 14;\n            break;\n\n          case 24:\n            _context.prev = 24;\n            peekr[\"return\"]();\n            return _context.finish(24);\n\n          case 27:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[13,, 24, 27]]);\n  }));\n  return _asyncIndexStrategy.apply(this, arguments);\n}\n\nfunction asyncConditionStrategy(_x4, _x5, _x6) {\n  return _asyncConditionStrategy.apply(this, arguments);\n}\n\nexports.asyncConditionStrategy = asyncConditionStrategy;\n\nfunction _asyncConditionStrategy() {\n  _asyncConditionStrategy = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(split, _ref2, source) {\n    var predicate, i, splat, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n      while (1) {\n        switch (_context2.prev = _context2.next) {\n          case 0:\n            predicate = _ref2.at;\n            i = 0;\n            splat = false;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context2.prev = 5;\n            _iterator = _asyncIterator(source);\n\n          case 7:\n            _context2.next = 9;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 9:\n            _step = _context2.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context2.next = 13;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 13:\n            _value = _context2.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context2.next = 30;\n              break;\n            }\n\n            value = _value;\n            _context2.t0 = !splat;\n\n            if (!_context2.t0) {\n              _context2.next = 21;\n              break;\n            }\n\n            _context2.next = 20;\n            return _awaitAsyncGenerator(predicate(value, i++));\n\n          case 20:\n            _context2.t0 = _context2.sent;\n\n          case 21:\n            if (!_context2.t0) {\n              _context2.next = 25;\n              break;\n            }\n\n            _context2.next = 24;\n            return split;\n\n          case 24:\n            splat = true;\n\n          case 25:\n            _context2.next = 27;\n            return value;\n\n          case 27:\n            _iteratorNormalCompletion = true;\n            _context2.next = 7;\n            break;\n\n          case 30:\n            _context2.next = 36;\n            break;\n\n          case 32:\n            _context2.prev = 32;\n            _context2.t1 = _context2[\"catch\"](5);\n            _didIteratorError = true;\n            _iteratorError = _context2.t1;\n\n          case 36:\n            _context2.prev = 36;\n            _context2.prev = 37;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context2.next = 41;\n              break;\n            }\n\n            _context2.next = 41;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 41:\n            _context2.prev = 41;\n\n            if (!_didIteratorError) {\n              _context2.next = 44;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 44:\n            return _context2.finish(41);\n\n          case 45:\n            return _context2.finish(36);\n\n          case 46:\n          case \"end\":\n            return _context2.stop();\n        }\n      }\n    }, _callee2, null, [[5, 32, 36, 46], [37,, 41, 45]]);\n  }));\n  return _asyncConditionStrategy.apply(this, arguments);\n}\n\nfunction __asyncBisect(source, at) {\n  var strategy = typeof at === 'number' ? asyncIndexStrategy : asyncConditionStrategy;\n  return new AsyncBisector(source, strategy, {\n    at: at\n  });\n}\n\nexports.__asyncBisect = __asyncBisect;\nvar asyncBisect = /*#__PURE__*/asyncIterableCurry(__asyncBisect, {\n  forceSync: true\n});\nexports.asyncBisect = asyncBisect;","function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(indexStrategy),\n    _marked2 = /*#__PURE__*/_regeneratorRuntime.mark(conditionStrategy);\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../../internal/bisector.js'),\n    Bisector = _require2.Bisector;\n\nvar _require3 = require('../$to-array/to-array.js'),\n    __toArray = _require3.__toArray;\n\nvar _require4 = require('../$peekerate/peekerate.js'),\n    __peekerate = _require4.__peekerate;\n\nfunction indexStrategy(split, _ref, source) {\n  var at, _source, idx, peekr;\n\n  return _regeneratorRuntime.wrap(function indexStrategy$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          at = _ref.at;\n          _source = at < 0 ? __toArray(source) : source;\n          idx = at < 0 ? _source.length + at : at;\n          peekr = __peekerate(_source);\n          _context.prev = 4;\n\n        case 5:\n          if (peekr.done) {\n            _context.next = 14;\n            break;\n          }\n\n          if (!(peekr.index === idx)) {\n            _context.next = 9;\n            break;\n          }\n\n          _context.next = 9;\n          return split;\n\n        case 9:\n          _context.next = 11;\n          return peekr.value;\n\n        case 11:\n          peekr.advance();\n          _context.next = 5;\n          break;\n\n        case 14:\n          _context.prev = 14;\n          peekr[\"return\"]();\n          return _context.finish(14);\n\n        case 17:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[4,, 14, 17]]);\n}\n\nexports.indexStrategy = indexStrategy;\n\nfunction conditionStrategy(split, _ref2, source) {\n  var predicate, i, splat, _iterator, _step, value;\n\n  return _regeneratorRuntime.wrap(function conditionStrategy$(_context2) {\n    while (1) {\n      switch (_context2.prev = _context2.next) {\n        case 0:\n          predicate = _ref2.at;\n          i = 0;\n          splat = false;\n          _iterator = _createForOfIteratorHelper(source);\n          _context2.prev = 4;\n\n          _iterator.s();\n\n        case 6:\n          if ((_step = _iterator.n()).done) {\n            _context2.next = 16;\n            break;\n          }\n\n          value = _step.value;\n\n          if (!(!splat && predicate(value, i++))) {\n            _context2.next = 12;\n            break;\n          }\n\n          _context2.next = 11;\n          return split;\n\n        case 11:\n          splat = true;\n\n        case 12:\n          _context2.next = 14;\n          return value;\n\n        case 14:\n          _context2.next = 6;\n          break;\n\n        case 16:\n          _context2.next = 21;\n          break;\n\n        case 18:\n          _context2.prev = 18;\n          _context2.t0 = _context2[\"catch\"](4);\n\n          _iterator.e(_context2.t0);\n\n        case 21:\n          _context2.prev = 21;\n\n          _iterator.f();\n\n          return _context2.finish(21);\n\n        case 24:\n        case \"end\":\n          return _context2.stop();\n      }\n    }\n  }, _marked2, null, [[4, 18, 21, 24]]);\n}\n\nexports.conditionStrategy = conditionStrategy;\n\nfunction __bisect(source, at) {\n  var strategy = typeof at === 'number' ? indexStrategy : conditionStrategy;\n  return new Bisector(source, strategy, {\n    at: at\n  });\n}\n\nexports.__bisect = __bisect;\nvar bisect = /*#__PURE__*/iterableCurry(__bisect, {\n  forceSync: true\n});\nexports.bisect = bisect;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$interleave/async-interleave.js'),\n    __asyncInterleave = _require2.__asyncInterleave;\n\nfunction asyncByComparison(_x, _x2) {\n  return _asyncByComparison.apply(this, arguments);\n}\n\nfunction _asyncByComparison() {\n  _asyncByComparison = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref, all) {\n    var compare,\n        candidate,\n        _len,\n        peekrs,\n        _key,\n        _iterator,\n        _step,\n        peekr,\n        _args = arguments;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            compare = _ref.compare;\n\n            for (_len = _args.length, peekrs = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n              peekrs[_key - 2] = _args[_key];\n            }\n\n          case 2:\n            if (all.done) {\n              _context.next = 12;\n              break;\n            }\n\n            candidate = all.value;\n            _iterator = _createForOfIteratorHelper(peekrs);\n\n            try {\n              for (_iterator.s(); !(_step = _iterator.n()).done;) {\n                peekr = _step.value;\n\n                if (!peekr.done && compare(peekr.value, candidate.value) < 0) {\n                  candidate = peekr;\n                }\n              }\n            } catch (err) {\n              _iterator.e(err);\n            } finally {\n              _iterator.f();\n            }\n\n            _context.next = 8;\n            return candidate.value;\n\n          case 8:\n            _context.next = 10;\n            return _awaitAsyncGenerator(candidate.advance());\n\n          case 10:\n            _context.next = 2;\n            break;\n\n          case 12:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncByComparison.apply(this, arguments);\n}\n\nfunction __asyncCollate(sources, compare) {\n  return __asyncInterleave(sources, asyncByComparison, {\n    compare: compare\n  });\n}\n\nexports.__asyncCollate = __asyncCollate;\nvar asyncCollate = /*#__PURE__*/asyncIterableCurry(__asyncCollate, {\n  variadic: true\n});\nexports.asyncCollate = asyncCollate;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(byComparison);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$interleave/interleave.js'),\n    __interleave = _require2.__interleave;\n\nfunction byComparison(_ref, all) {\n  var compare,\n      candidate,\n      _len,\n      peekrs,\n      _key,\n      _iterator,\n      _step,\n      peekr,\n      _args = arguments;\n\n  return _regeneratorRuntime.wrap(function byComparison$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          compare = _ref.compare;\n\n          for (_len = _args.length, peekrs = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n            peekrs[_key - 2] = _args[_key];\n          }\n\n        case 2:\n          if (all.done) {\n            _context.next = 11;\n            break;\n          }\n\n          candidate = all.value;\n          _iterator = _createForOfIteratorHelper(peekrs);\n\n          try {\n            for (_iterator.s(); !(_step = _iterator.n()).done;) {\n              peekr = _step.value;\n\n              if (!peekr.done && compare(peekr.value, candidate.value) < 0) {\n                candidate = peekr;\n              }\n            }\n          } catch (err) {\n            _iterator.e(err);\n          } finally {\n            _iterator.f();\n          }\n\n          _context.next = 8;\n          return candidate.value;\n\n        case 8:\n          candidate.advance();\n          _context.next = 2;\n          break;\n\n        case 11:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nfunction __collate(sources, compare) {\n  return __interleave(sources, byComparison, {\n    compare: compare\n  });\n}\n\nexports.__collate = __collate;\nvar collate = /*#__PURE__*/iterableCurry(__collate, {\n  variadic: true\n});\nexports.collate = collate;","var _slicedToArray = require(\"@babel/runtime/helpers/slicedToArray\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncEnsureIterable = _require.asyncEnsureIterable;\n\nvar _require2 = require('../../internal/curry.js'),\n    curry = _require2.curry;\n\nvar _require3 = require('../$zip/async-zip.js'),\n    __asyncZip = _require3.__asyncZip;\n\nvar _require4 = require('../$filter/async-filter.js'),\n    __asyncFilter = _require4.__asyncFilter;\n\nvar _require5 = require('../$map/async-map.js'),\n    __asyncMap = _require5.__asyncMap;\n\nfunction __asyncCompress(source, included) {\n  return __asyncMap(__asyncFilter(__asyncZip([source, included]), function (_ref) {\n    var _ref2 = _slicedToArray(_ref, 2),\n        isIncluded = _ref2[1];\n\n    return isIncluded;\n  }), function (_ref3) {\n    var _ref4 = _slicedToArray(_ref3, 1),\n        value = _ref4[0];\n\n    return value;\n  });\n}\n\nexports.__asyncCompress = __asyncCompress;\nvar asyncCompress = /*#__PURE__*/curry(function $compress(source, included) {\n  return __asyncCompress(asyncEnsureIterable(source), asyncEnsureIterable(included));\n});\nexports.asyncCompress = asyncCompress;","var _slicedToArray = require(\"@babel/runtime/helpers/slicedToArray\");\n\nvar _require = require('../../internal/iterable.js'),\n    ensureIterable = _require.ensureIterable;\n\nvar _require2 = require('../../internal/curry.js'),\n    curry = _require2.curry;\n\nvar _require3 = require('../$zip/zip.js'),\n    __zip = _require3.__zip;\n\nvar _require4 = require('../$filter/filter.js'),\n    __filter = _require4.__filter;\n\nvar _require5 = require('../$map/map.js'),\n    __map = _require5.__map;\n\nfunction __compress(source, included) {\n  return __map(__filter(__zip([source, included]), function (_ref) {\n    var _ref2 = _slicedToArray(_ref, 2),\n        isIncluded = _ref2[1];\n\n    return isIncluded;\n  }), function (_ref3) {\n    var _ref4 = _slicedToArray(_ref3, 1),\n        value = _ref4[0];\n\n    return value;\n  });\n}\n\nexports.__compress = __compress;\nvar compress = /*#__PURE__*/curry(function $compress(source, included) {\n  return __compress(ensureIterable(source), ensureIterable(included));\n});\nexports.compress = compress;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _asyncGeneratorDelegate = require(\"@babel/runtime/helpers/asyncGeneratorDelegate\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncWrapWithIterableIterator = _require.asyncWrapWithIterableIterator,\n    asyncEnsureIterable = _require.asyncEnsureIterable;\n\nfunction __asyncConcat() {\n  return _asyncConcat.apply(this, arguments);\n}\n\nexports.__asyncConcat = __asyncConcat;\n\nfunction _asyncConcat() {\n  _asyncConcat = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {\n    var _len,\n        sources,\n        _key,\n        _i,\n        _sources,\n        iterable,\n        _args = arguments;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            for (_len = _args.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {\n              sources[_key] = _args[_key];\n            }\n\n            _i = 0, _sources = sources;\n\n          case 2:\n            if (!(_i < _sources.length)) {\n              _context.next = 8;\n              break;\n            }\n\n            iterable = _sources[_i];\n            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(asyncEnsureIterable(iterable)), _awaitAsyncGenerator), \"t0\", 5);\n\n          case 5:\n            _i++;\n            _context.next = 2;\n            break;\n\n          case 8:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncConcat.apply(this, arguments);\n}\n\nvar asyncConcat = /*#__PURE__*/asyncWrapWithIterableIterator(__asyncConcat);\nexports.asyncConcat = asyncConcat;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__concat);\n\nvar _require = require('../../internal/iterable.js'),\n    wrapWithIterableIterator = _require.wrapWithIterableIterator,\n    ensureIterable = _require.ensureIterable;\n\nfunction __concat() {\n  var _len,\n      sources,\n      _key,\n      _i,\n      _sources,\n      iterable,\n      _args = arguments;\n\n  return _regeneratorRuntime.wrap(function __concat$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          for (_len = _args.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {\n            sources[_key] = _args[_key];\n          }\n\n          _i = 0, _sources = sources;\n\n        case 2:\n          if (!(_i < _sources.length)) {\n            _context.next = 8;\n            break;\n          }\n\n          iterable = _sources[_i];\n          return _context.delegateYield(ensureIterable(iterable), \"t0\", 5);\n\n        case 5:\n          _i++;\n          _context.next = 2;\n          break;\n\n        case 8:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nexports.__concat = __concat;\nvar concat = /*#__PURE__*/wrapWithIterableIterator(__concat);\nexports.concat = concat;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nfunction __asyncConsume(_x) {\n  return _asyncConsume.apply(this, arguments);\n}\n\nfunction _asyncConsume() {\n  _asyncConsume = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable) {\n    var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, _;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 2;\n            _iterator = _asyncIterator(iterable);\n\n          case 4:\n            _context.next = 6;\n            return _iterator.next();\n\n          case 6:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 10;\n            return _step.value;\n\n          case 10:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 16;\n              break;\n            }\n\n            _ = _value;\n\n          case 13:\n            _iteratorNormalCompletion = true;\n            _context.next = 4;\n            break;\n\n          case 16:\n            _context.next = 22;\n            break;\n\n          case 18:\n            _context.prev = 18;\n            _context.t0 = _context[\"catch\"](2);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 22:\n            _context.prev = 22;\n            _context.prev = 23;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 27;\n              break;\n            }\n\n            _context.next = 27;\n            return _iterator[\"return\"]();\n\n          case 27:\n            _context.prev = 27;\n\n            if (!_didIteratorError) {\n              _context.next = 30;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 30:\n            return _context.finish(27);\n\n          case 31:\n            return _context.finish(22);\n\n          case 32:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[2, 18, 22, 32], [23,, 27, 31]]);\n  }));\n  return _asyncConsume.apply(this, arguments);\n}\n\nexports.__asyncConsume = __asyncConsume;\nvar asyncConsume = /*#__PURE__*/asyncIterableCurry(__asyncConsume, {\n  reduces: true\n});\nexports.asyncConsume = asyncConsume;","function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nfunction __consume(iterable) {\n  var _iterator = _createForOfIteratorHelper(iterable),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var _ = _step.value;\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n}\n\nexports.__consume = __consume;\nvar consume = /*#__PURE__*/iterableCurry(__consume, {\n  reduces: true\n});\nexports.consume = consume;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _asyncGeneratorDelegate = require(\"@babel/runtime/helpers/asyncGeneratorDelegate\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$to-array/async-to-array.js'),\n    __asyncToArray = _require2.__asyncToArray;\n\nvar _require3 = require('./cycle-times.js'),\n    __cycleTimes = _require3.__cycleTimes;\n\nfunction __asyncCycleTimes(_x, _x2) {\n  return _asyncCycleTimes.apply(this, arguments);\n}\n\nexports.__asyncCycleTimes = __asyncCycleTimes;\n\nfunction _asyncCycleTimes() {\n  _asyncCycleTimes = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, n) {\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            _context.t0 = _asyncGeneratorDelegate;\n            _context.t1 = _asyncIterator;\n            _context.t2 = __cycleTimes;\n            _context.next = 5;\n            return _awaitAsyncGenerator(__asyncToArray(source));\n\n          case 5:\n            _context.t3 = _context.sent;\n            _context.t4 = n;\n            _context.t5 = (0, _context.t2)(_context.t3, _context.t4);\n            _context.t6 = (0, _context.t1)(_context.t5);\n            _context.t7 = _awaitAsyncGenerator;\n            return _context.delegateYield((0, _context.t0)(_context.t6, _context.t7), \"t8\", 11);\n\n          case 11:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncCycleTimes.apply(this, arguments);\n}\n\nvar asyncCycleTimes = /*#__PURE__*/asyncIterableCurry(__asyncCycleTimes);\nexports.asyncCycleTimes = asyncCycleTimes;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__cycleTimes);\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$to-array/to-array.js'),\n    __toArray = _require2.__toArray;\n\nfunction __cycleTimes(source, n) {\n  var arr;\n  return _regeneratorRuntime.wrap(function __cycleTimes$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          arr = Array.isArray(source) ? source : __toArray(source);\n\n          if (arr.length) {\n            _context.next = 3;\n            break;\n          }\n\n          return _context.abrupt(\"return\");\n\n        case 3:\n          if (!n--) {\n            _context.next = 7;\n            break;\n          }\n\n          return _context.delegateYield(arr, \"t0\", 5);\n\n        case 5:\n          _context.next = 3;\n          break;\n\n        case 7:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nexports.__cycleTimes = __cycleTimes;\nvar cycleTimes = /*#__PURE__*/iterableCurry(__cycleTimes);\nexports.cycleTimes = cycleTimes;","var _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$cycle-times/async-cycle-times.js'),\n    __asyncCycleTimes = _require2.__asyncCycleTimes;\n\nfunction __asyncCycle(source) {\n  return __asyncCycleTimes(source, Infinity);\n}\n\nexports.__asyncCycle = __asyncCycle;\nvar asyncCycle = /*#__PURE__*/asyncIterableCurry(__asyncCycle);\nexports.asyncCycle = asyncCycle;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$cycle-times/cycle-times.js'),\n    __cycleTimes = _require2.__cycleTimes;\n\nfunction __cycle(source) {\n  return __cycleTimes(source, Infinity);\n}\n\nexports.__cycle = __cycle;\nvar cycle = /*#__PURE__*/iterableCurry(__cycle);\nexports.cycle = cycle;","var _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIsIterable = _require.asyncIsIterable,\n    asyncIsWrappable = _require.asyncIsWrappable;\n\nvar _require2 = require('../$map/map.js'),\n    __map = _require2.__map;\n\nvar _require3 = require('../$every/every.js'),\n    __every = _require3.__every;\n\nvar _require4 = require('../$zip-all/async-zip-all.js'),\n    __asyncZipAll = _require4.__asyncZipAll;\n\nvar _require5 = require('../$slice/slice.js'),\n    __sliceFromStart = _require5.__sliceFromStart;\n\nvar none = Symbol('none');\nvar zipAllConfig = {\n  filler: none\n};\n\nvar asyncEmpty = /*#__PURE__*/function () {\n  var _ref = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n\n  return function asyncEmpty() {\n    return _ref.apply(this, arguments);\n  };\n}();\n\nvar asyncIterableOrEmpty = function asyncIterableOrEmpty(value) {\n  return value == null ? asyncEmpty() : value;\n};\n\nfunction _asyncDeepEqual(_x, _x2, _x3) {\n  return _asyncDeepEqual2.apply(this, arguments);\n}\n\nfunction _asyncDeepEqual2() {\n  _asyncDeepEqual2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(values, same, isIterable) {\n    var depth,\n        _iteratorNormalCompletion,\n        _didIteratorError,\n        _iteratorError,\n        _iterator,\n        _step,\n        _value,\n        stepValues,\n        firstValue,\n        _iterator2,\n        _step2,\n        value,\n        _args2 = arguments;\n\n    return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n      while (1) {\n        switch (_context2.prev = _context2.next) {\n          case 0:\n            depth = _args2.length > 3 && _args2[3] !== undefined ? _args2[3] : 0;\n\n            if (!__every(values, function (value) {\n              return typeof value !== 'string' && isIterable(value);\n            })) {\n              _context2.next = 40;\n              break;\n            }\n\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context2.prev = 4;\n            _iterator = _asyncIterator(__asyncZipAll(__map(values, asyncIterableOrEmpty), zipAllConfig));\n\n          case 6:\n            _context2.next = 8;\n            return _iterator.next();\n\n          case 8:\n            _step = _context2.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context2.next = 12;\n            return _step.value;\n\n          case 12:\n            _value = _context2.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context2.next = 22;\n              break;\n            }\n\n            stepValues = _value;\n            _context2.next = 17;\n            return _asyncDeepEqual(stepValues, same, isIterable, depth + 1);\n\n          case 17:\n            if (_context2.sent) {\n              _context2.next = 19;\n              break;\n            }\n\n            return _context2.abrupt(\"return\", false);\n\n          case 19:\n            _iteratorNormalCompletion = true;\n            _context2.next = 6;\n            break;\n\n          case 22:\n            _context2.next = 28;\n            break;\n\n          case 24:\n            _context2.prev = 24;\n            _context2.t0 = _context2[\"catch\"](4);\n            _didIteratorError = true;\n            _iteratorError = _context2.t0;\n\n          case 28:\n            _context2.prev = 28;\n            _context2.prev = 29;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context2.next = 33;\n              break;\n            }\n\n            _context2.next = 33;\n            return _iterator[\"return\"]();\n\n          case 33:\n            _context2.prev = 33;\n\n            if (!_didIteratorError) {\n              _context2.next = 36;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 36:\n            return _context2.finish(33);\n\n          case 37:\n            return _context2.finish(28);\n\n          case 38:\n            _context2.next = 58;\n            break;\n\n          case 40:\n            firstValue = values[0];\n            _iterator2 = _createForOfIteratorHelper(__sliceFromStart(values, 1));\n            _context2.prev = 42;\n\n            _iterator2.s();\n\n          case 44:\n            if ((_step2 = _iterator2.n()).done) {\n              _context2.next = 50;\n              break;\n            }\n\n            value = _step2.value;\n\n            if (same(value, firstValue, depth)) {\n              _context2.next = 48;\n              break;\n            }\n\n            return _context2.abrupt(\"return\", false);\n\n          case 48:\n            _context2.next = 44;\n            break;\n\n          case 50:\n            _context2.next = 55;\n            break;\n\n          case 52:\n            _context2.prev = 52;\n            _context2.t1 = _context2[\"catch\"](42);\n\n            _iterator2.e(_context2.t1);\n\n          case 55:\n            _context2.prev = 55;\n\n            _iterator2.f();\n\n            return _context2.finish(55);\n\n          case 58:\n            return _context2.abrupt(\"return\", true);\n\n          case 59:\n          case \"end\":\n            return _context2.stop();\n        }\n      }\n    }, _callee2, null, [[4, 24, 28, 38], [29,, 33, 37], [42, 52, 55, 58]]);\n  }));\n  return _asyncDeepEqual2.apply(this, arguments);\n}\n\nexports._asyncDeepEqual = _asyncDeepEqual;\n\nfunction __asyncDeepEqual(values) {\n  var same = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Object.is;\n  var coerceNil = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n  return values.length <= 1 ? true : _asyncDeepEqual(values, same, coerceNil ? asyncIsWrappable : asyncIsIterable);\n}\n\nexports.__asyncDeepEqual = __asyncDeepEqual;\n\nfunction asyncDeepEqual() {\n  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {\n    values[_key] = arguments[_key];\n  }\n\n  return __asyncDeepEqual(values);\n}\n\nexports.asyncDeepEqual = asyncDeepEqual;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    isIterable = _require.isIterable,\n    isWrappable = _require.isWrappable;\n\nvar _require2 = require('../$map/map.js'),\n    __map = _require2.__map;\n\nvar _require3 = require('../$every/every.js'),\n    __every = _require3.__every;\n\nvar _require4 = require('../$zip-all/zip-all.js'),\n    __zipAll = _require4.__zipAll;\n\nvar _require5 = require('../$slice/slice.js'),\n    __sliceFromStart = _require5.__sliceFromStart;\n\nvar none = Symbol('none');\nvar zipAllConfig = {\n  filler: none\n};\n\nvar empty = /*#__PURE__*/_regeneratorRuntime.mark(function empty() {\n  return _regeneratorRuntime.wrap(function empty$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, empty);\n});\n\nvar iterableOrEmpty = function iterableOrEmpty(value) {\n  return value == null ? empty() : value;\n};\n\nfunction _deepEqual(values, same, isIterable) {\n  var depth = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;\n\n  if (__every(values, function (value) {\n    return typeof value !== 'string' && isIterable(value);\n  })) {\n    var _iterator = _createForOfIteratorHelper(__zipAll(__map(values, iterableOrEmpty), zipAllConfig)),\n        _step;\n\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var stepValues = _step.value;\n        if (!_deepEqual(stepValues, same, isIterable, depth + 1)) return false;\n      }\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\n    }\n  } else {\n    var firstValue = values[0];\n\n    var _iterator2 = _createForOfIteratorHelper(__sliceFromStart(values, 1)),\n        _step2;\n\n    try {\n      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n        var value = _step2.value;\n        if (!same(value, firstValue, depth)) return false;\n      }\n    } catch (err) {\n      _iterator2.e(err);\n    } finally {\n      _iterator2.f();\n    }\n  }\n\n  return true;\n}\n\nexports._deepEqual = _deepEqual;\n\nfunction __deepEqual(values) {\n  var same = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Object.is;\n  var coerceNil = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n  return values.length <= 1 ? true : _deepEqual(values, same, coerceNil ? isWrappable : isIterable);\n}\n\nexports.__deepEqual = __deepEqual;\n\nfunction deepEqual() {\n  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {\n    values[_key] = arguments[_key];\n  }\n\n  return __deepEqual(values);\n}\n\nexports.deepEqual = deepEqual;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nfunction __asyncDistinct(_x, _x2) {\n  return _asyncDistinct.apply(this, arguments);\n}\n\nexports.__asyncDistinct = __asyncDistinct;\n\nfunction _asyncDistinct() {\n  _asyncDistinct = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, selector) {\n    var set, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value, key;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            set = new Set();\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 3;\n            _iterator = _asyncIterator(source);\n\n          case 5:\n            _context.next = 7;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 7:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 11;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 11:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 23;\n              break;\n            }\n\n            value = _value;\n            key = selector ? selector(value) : value;\n\n            if (!set.has(key)) {\n              _context.next = 17;\n              break;\n            }\n\n            return _context.abrupt(\"continue\", 20);\n\n          case 17:\n            set.add(key);\n            _context.next = 20;\n            return value;\n\n          case 20:\n            _iteratorNormalCompletion = true;\n            _context.next = 5;\n            break;\n\n          case 23:\n            _context.next = 29;\n            break;\n\n          case 25:\n            _context.prev = 25;\n            _context.t0 = _context[\"catch\"](3);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 29:\n            _context.prev = 29;\n            _context.prev = 30;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 34;\n              break;\n            }\n\n            _context.next = 34;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 34:\n            _context.prev = 34;\n\n            if (!_didIteratorError) {\n              _context.next = 37;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 37:\n            return _context.finish(34);\n\n          case 38:\n            return _context.finish(29);\n\n          case 39:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[3, 25, 29, 39], [30,, 34, 38]]);\n  }));\n  return _asyncDistinct.apply(this, arguments);\n}\n\nvar asyncDistinct = asyncIterableCurry(__asyncDistinct, {\n  minArgs: 0,\n  maxArgs: 1\n});\nexports.asyncDistinct = asyncDistinct;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__distinct);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nfunction __distinct(source, selector) {\n  var set, _iterator, _step, value, key;\n\n  return _regeneratorRuntime.wrap(function __distinct$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          set = new Set();\n          _iterator = _createForOfIteratorHelper(source);\n          _context.prev = 2;\n\n          _iterator.s();\n\n        case 4:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 14;\n            break;\n          }\n\n          value = _step.value;\n          key = selector ? selector(value) : value;\n\n          if (!set.has(key)) {\n            _context.next = 9;\n            break;\n          }\n\n          return _context.abrupt(\"continue\", 12);\n\n        case 9:\n          set.add(key);\n          _context.next = 12;\n          return value;\n\n        case 12:\n          _context.next = 4;\n          break;\n\n        case 14:\n          _context.next = 19;\n          break;\n\n        case 16:\n          _context.prev = 16;\n          _context.t0 = _context[\"catch\"](2);\n\n          _iterator.e(_context.t0);\n\n        case 19:\n          _context.prev = 19;\n\n          _iterator.f();\n\n          return _context.finish(19);\n\n        case 22:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[2, 16, 19, 22]]);\n}\n\nexports.__distinct = __distinct;\nvar distinct = iterableCurry(__distinct, {\n  minArgs: 0,\n  maxArgs: 1\n});\nexports.distinct = distinct;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nfunction __asyncDropWhile(_x, _x2) {\n  return _asyncDropWhile.apply(this, arguments);\n}\n\nexports.__asyncDropWhile = __asyncDropWhile;\n\nfunction _asyncDropWhile() {\n  _asyncDropWhile = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, predicate) {\n    var drop, c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            drop = true;\n            c = 0;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 4;\n            _iterator = _asyncIterator(source);\n\n          case 6:\n            _context.next = 8;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 8:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 12;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 12:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 29;\n              break;\n            }\n\n            value = _value;\n\n            if (drop) {\n              _context.next = 20;\n              break;\n            }\n\n            _context.next = 18;\n            return value;\n\n          case 18:\n            _context.next = 26;\n            break;\n\n          case 20:\n            _context.next = 22;\n            return _awaitAsyncGenerator(predicate(value, c++));\n\n          case 22:\n            drop = _context.sent;\n\n            if (drop) {\n              _context.next = 26;\n              break;\n            }\n\n            _context.next = 26;\n            return value;\n\n          case 26:\n            _iteratorNormalCompletion = true;\n            _context.next = 6;\n            break;\n\n          case 29:\n            _context.next = 35;\n            break;\n\n          case 31:\n            _context.prev = 31;\n            _context.t0 = _context[\"catch\"](4);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 35:\n            _context.prev = 35;\n            _context.prev = 36;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 40;\n              break;\n            }\n\n            _context.next = 40;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 40:\n            _context.prev = 40;\n\n            if (!_didIteratorError) {\n              _context.next = 43;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 43:\n            return _context.finish(40);\n\n          case 44:\n            return _context.finish(35);\n\n          case 45:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[4, 31, 35, 45], [36,, 40, 44]]);\n  }));\n  return _asyncDropWhile.apply(this, arguments);\n}\n\nvar asyncDropWhile = /*#__PURE__*/asyncIterableCurry(__asyncDropWhile);\nexports.asyncDropWhile = asyncDropWhile;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__dropWhile);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nfunction __dropWhile(source, predicate) {\n  var drop, c, _iterator, _step, value;\n\n  return _regeneratorRuntime.wrap(function __dropWhile$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          drop = true;\n          c = 0;\n          _iterator = _createForOfIteratorHelper(source);\n          _context.prev = 3;\n\n          _iterator.s();\n\n        case 5:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 18;\n            break;\n          }\n\n          value = _step.value;\n\n          if (drop) {\n            _context.next = 12;\n            break;\n          }\n\n          _context.next = 10;\n          return value;\n\n        case 10:\n          _context.next = 16;\n          break;\n\n        case 12:\n          drop = predicate(value, c++);\n\n          if (drop) {\n            _context.next = 16;\n            break;\n          }\n\n          _context.next = 16;\n          return value;\n\n        case 16:\n          _context.next = 5;\n          break;\n\n        case 18:\n          _context.next = 23;\n          break;\n\n        case 20:\n          _context.prev = 20;\n          _context.t0 = _context[\"catch\"](3);\n\n          _iterator.e(_context.t0);\n\n        case 23:\n          _context.prev = 23;\n\n          _iterator.f();\n\n          return _context.finish(23);\n\n        case 26:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[3, 20, 23, 26]]);\n}\n\nexports.__dropWhile = __dropWhile;\nvar dropWhile = /*#__PURE__*/iterableCurry(__dropWhile);\nexports.dropWhile = dropWhile;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nfunction __asyncDrop(_x, _x2) {\n  return _asyncDrop.apply(this, arguments);\n}\n\nexports.__asyncDrop = __asyncDrop;\n\nfunction _asyncDrop() {\n  _asyncDrop = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, n) {\n    var i, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            i = 0;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 3;\n            _iterator = _asyncIterator(iterable);\n\n          case 5:\n            _context.next = 7;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 7:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 11;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 11:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 20;\n              break;\n            }\n\n            value = _value;\n\n            if (!(i++ >= n)) {\n              _context.next = 17;\n              break;\n            }\n\n            _context.next = 17;\n            return value;\n\n          case 17:\n            _iteratorNormalCompletion = true;\n            _context.next = 5;\n            break;\n\n          case 20:\n            _context.next = 26;\n            break;\n\n          case 22:\n            _context.prev = 22;\n            _context.t0 = _context[\"catch\"](3);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 26:\n            _context.prev = 26;\n            _context.prev = 27;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 31;\n              break;\n            }\n\n            _context.next = 31;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 31:\n            _context.prev = 31;\n\n            if (!_didIteratorError) {\n              _context.next = 34;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 34:\n            return _context.finish(31);\n\n          case 35:\n            return _context.finish(26);\n\n          case 36:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[3, 22, 26, 36], [27,, 31, 35]]);\n  }));\n  return _asyncDrop.apply(this, arguments);\n}\n\nvar asyncDrop = /*#__PURE__*/asyncIterableCurry(__asyncDrop);\nexports.asyncDrop = asyncDrop;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__drop);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nfunction __drop(iterable, n) {\n  var i, _iterator, _step, value;\n\n  return _regeneratorRuntime.wrap(function __drop$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          i = 0;\n          _iterator = _createForOfIteratorHelper(iterable);\n          _context.prev = 2;\n\n          _iterator.s();\n\n        case 4:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 11;\n            break;\n          }\n\n          value = _step.value;\n\n          if (!(i++ >= n)) {\n            _context.next = 9;\n            break;\n          }\n\n          _context.next = 9;\n          return value;\n\n        case 9:\n          _context.next = 4;\n          break;\n\n        case 11:\n          _context.next = 16;\n          break;\n\n        case 13:\n          _context.prev = 13;\n          _context.t0 = _context[\"catch\"](2);\n\n          _iterator.e(_context.t0);\n\n        case 16:\n          _context.prev = 16;\n\n          _iterator.f();\n\n          return _context.finish(16);\n\n        case 19:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[2, 13, 16, 19]]);\n}\n\nexports.__drop = __drop;\nvar drop = /*#__PURE__*/iterableCurry(__drop);\nexports.drop = drop;","var _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$map/async-map.js'),\n    __asyncMap = _require2.__asyncMap;\n\nfunction __asyncEnumerate(source) {\n  var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  return __asyncMap(source, function (value, i) {\n    return [start + i, value];\n  });\n}\n\nexports.__asyncEnumerate = __asyncEnumerate;\nvar asyncEnumerate = /*#__PURE__*/asyncIterableCurry(__asyncEnumerate, {\n  minArgs: 0,\n  maxArgs: 1\n});\nexports.asyncEnumerate = asyncEnumerate;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$map/map.js'),\n    __map = _require2.__map;\n\nfunction __enumerate(source) {\n  var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  return __map(source, function (value, i) {\n    return [start + i, value];\n  });\n}\n\nexports.__enumerate = __enumerate;\nvar enumerate = /*#__PURE__*/iterableCurry(__enumerate, {\n  minArgs: 0,\n  maxArgs: 1\n});\nexports.enumerate = enumerate;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$zip-all/async-zip-all.js'),\n    __asyncZipAll = _require2.__asyncZipAll;\n\nvar _require3 = require('../$slice/slice.js'),\n    __sliceFromStart = _require3.__sliceFromStart;\n\nvar none = Symbol('none');\nvar zipAllConfig = {\n  filler: none\n};\n\nfunction __asyncEqual(_x) {\n  return _asyncEqual.apply(this, arguments);\n}\n\nfunction _asyncEqual() {\n  _asyncEqual = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterables) {\n    var same,\n        _iteratorNormalCompletion,\n        _didIteratorError,\n        _iteratorError,\n        _iterator,\n        _step,\n        _value,\n        stepValues,\n        firstValue,\n        _iterator2,\n        _step2,\n        value,\n        _args = arguments;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            same = _args.length > 1 && _args[1] !== undefined ? _args[1] : Object.is;\n\n            if (!(iterables.length <= 1)) {\n              _context.next = 3;\n              break;\n            }\n\n            return _context.abrupt(\"return\", true);\n\n          case 3:\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 5;\n            _iterator = _asyncIterator(__asyncZipAll(iterables, zipAllConfig));\n\n          case 7:\n            _context.next = 9;\n            return _iterator.next();\n\n          case 9:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 13;\n            return _step.value;\n\n          case 13:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 37;\n              break;\n            }\n\n            stepValues = _value;\n            firstValue = stepValues[0];\n            _iterator2 = _createForOfIteratorHelper(__sliceFromStart(stepValues, 1));\n            _context.prev = 18;\n\n            _iterator2.s();\n\n          case 20:\n            if ((_step2 = _iterator2.n()).done) {\n              _context.next = 26;\n              break;\n            }\n\n            value = _step2.value;\n\n            if (same(value, firstValue)) {\n              _context.next = 24;\n              break;\n            }\n\n            return _context.abrupt(\"return\", false);\n\n          case 24:\n            _context.next = 20;\n            break;\n\n          case 26:\n            _context.next = 31;\n            break;\n\n          case 28:\n            _context.prev = 28;\n            _context.t0 = _context[\"catch\"](18);\n\n            _iterator2.e(_context.t0);\n\n          case 31:\n            _context.prev = 31;\n\n            _iterator2.f();\n\n            return _context.finish(31);\n\n          case 34:\n            _iteratorNormalCompletion = true;\n            _context.next = 7;\n            break;\n\n          case 37:\n            _context.next = 43;\n            break;\n\n          case 39:\n            _context.prev = 39;\n            _context.t1 = _context[\"catch\"](5);\n            _didIteratorError = true;\n            _iteratorError = _context.t1;\n\n          case 43:\n            _context.prev = 43;\n            _context.prev = 44;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 48;\n              break;\n            }\n\n            _context.next = 48;\n            return _iterator[\"return\"]();\n\n          case 48:\n            _context.prev = 48;\n\n            if (!_didIteratorError) {\n              _context.next = 51;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 51:\n            return _context.finish(48);\n\n          case 52:\n            return _context.finish(43);\n\n          case 53:\n            return _context.abrupt(\"return\", true);\n\n          case 54:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[5, 39, 43, 53], [18, 28, 31, 34], [44,, 48, 52]]);\n  }));\n  return _asyncEqual.apply(this, arguments);\n}\n\nexports.__asyncEqual = __asyncEqual;\nvar asyncEqual = /*#__PURE__*/asyncIterableCurry(__asyncEqual, {\n  minArgs: 0,\n  maxArgs: 1,\n  variadic: true,\n  reduces: true\n});\nexports.asyncEqual = asyncEqual;","function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$zip-all/zip-all.js'),\n    __zipAll = _require2.__zipAll;\n\nvar _require3 = require('../$slice/slice.js'),\n    __sliceFromStart = _require3.__sliceFromStart;\n\nvar none = Symbol('none');\nvar zipAllConfig = {\n  filler: none\n};\n\nfunction __equal(iterables) {\n  var same = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Object.is;\n  if (iterables.length <= 1) return true;\n\n  var _iterator = _createForOfIteratorHelper(__zipAll(iterables, zipAllConfig)),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var stepValues = _step.value;\n      var firstValue = stepValues[0];\n\n      var _iterator2 = _createForOfIteratorHelper(__sliceFromStart(stepValues, 1)),\n          _step2;\n\n      try {\n        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n          var value = _step2.value;\n          if (!same(value, firstValue)) return false;\n        }\n      } catch (err) {\n        _iterator2.e(err);\n      } finally {\n        _iterator2.f();\n      }\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  return true;\n}\n\nexports.__equal = __equal;\nvar equal = /*#__PURE__*/iterableCurry(__equal, {\n  minArgs: 0,\n  maxArgs: 1,\n  variadic: true,\n  reduces: true\n});\nexports.equal = equal;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nfunction __asyncEvery(_x, _x2) {\n  return _asyncEvery.apply(this, arguments);\n}\n\nfunction _asyncEvery() {\n  _asyncEvery = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, predicate) {\n    var c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            c = 0;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 3;\n            _iterator = _asyncIterator(iterable);\n\n          case 5:\n            _context.next = 7;\n            return _iterator.next();\n\n          case 7:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 11;\n            return _step.value;\n\n          case 11:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 21;\n              break;\n            }\n\n            value = _value;\n            _context.next = 16;\n            return predicate(value, c++);\n\n          case 16:\n            if (_context.sent) {\n              _context.next = 18;\n              break;\n            }\n\n            return _context.abrupt(\"return\", false);\n\n          case 18:\n            _iteratorNormalCompletion = true;\n            _context.next = 5;\n            break;\n\n          case 21:\n            _context.next = 27;\n            break;\n\n          case 23:\n            _context.prev = 23;\n            _context.t0 = _context[\"catch\"](3);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 27:\n            _context.prev = 27;\n            _context.prev = 28;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 32;\n              break;\n            }\n\n            _context.next = 32;\n            return _iterator[\"return\"]();\n\n          case 32:\n            _context.prev = 32;\n\n            if (!_didIteratorError) {\n              _context.next = 35;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 35:\n            return _context.finish(32);\n\n          case 36:\n            return _context.finish(27);\n\n          case 37:\n            return _context.abrupt(\"return\", true);\n\n          case 38:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[3, 23, 27, 37], [28,, 32, 36]]);\n  }));\n  return _asyncEvery.apply(this, arguments);\n}\n\nexports.__asyncEvery = __asyncEvery;\nvar asyncEvery = /*#__PURE__*/asyncIterableCurry(__asyncEvery, {\n  reduces: true\n});\nexports.asyncEvery = asyncEvery;","function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nfunction __every(iterable, predicate) {\n  var c = 0;\n\n  var _iterator = _createForOfIteratorHelper(iterable),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var value = _step.value;\n\n      if (!predicate(value, c++)) {\n        return false;\n      }\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  return true;\n}\n\nexports.__every = __every;\nvar every = /*#__PURE__*/iterableCurry(__every, {\n  reduces: true\n});\nexports.every = every;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nfunction __asyncFilter(_x, _x2) {\n  return _asyncFilter.apply(this, arguments);\n}\n\nexports.__asyncFilter = __asyncFilter;\n\nfunction _asyncFilter() {\n  _asyncFilter = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, predicate) {\n    var c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            c = 0;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 3;\n            _iterator = _asyncIterator(source);\n\n          case 5:\n            _context.next = 7;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 7:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 11;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 11:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 22;\n              break;\n            }\n\n            value = _value;\n            _context.next = 16;\n            return _awaitAsyncGenerator(predicate(value, c++));\n\n          case 16:\n            if (!_context.sent) {\n              _context.next = 19;\n              break;\n            }\n\n            _context.next = 19;\n            return value;\n\n          case 19:\n            _iteratorNormalCompletion = true;\n            _context.next = 5;\n            break;\n\n          case 22:\n            _context.next = 28;\n            break;\n\n          case 24:\n            _context.prev = 24;\n            _context.t0 = _context[\"catch\"](3);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 28:\n            _context.prev = 28;\n            _context.prev = 29;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 33;\n              break;\n            }\n\n            _context.next = 33;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 33:\n            _context.prev = 33;\n\n            if (!_didIteratorError) {\n              _context.next = 36;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 36:\n            return _context.finish(33);\n\n          case 37:\n            return _context.finish(28);\n\n          case 38:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[3, 24, 28, 38], [29,, 33, 37]]);\n  }));\n  return _asyncFilter.apply(this, arguments);\n}\n\nvar asyncFilter = /*#__PURE__*/asyncIterableCurry(__asyncFilter);\nexports.asyncFilter = asyncFilter;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__filter);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nfunction __filter(source, predicate) {\n  var c, _iterator, _step, value;\n\n  return _regeneratorRuntime.wrap(function __filter$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          c = 0;\n          _iterator = _createForOfIteratorHelper(source);\n          _context.prev = 2;\n\n          _iterator.s();\n\n        case 4:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 11;\n            break;\n          }\n\n          value = _step.value;\n\n          if (!predicate(value, c++)) {\n            _context.next = 9;\n            break;\n          }\n\n          _context.next = 9;\n          return value;\n\n        case 9:\n          _context.next = 4;\n          break;\n\n        case 11:\n          _context.next = 16;\n          break;\n\n        case 13:\n          _context.prev = 13;\n          _context.t0 = _context[\"catch\"](2);\n\n          _iterator.e(_context.t0);\n\n        case 16:\n          _context.prev = 16;\n\n          _iterator.f();\n\n          return _context.finish(16);\n\n        case 19:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[2, 13, 16, 19]]);\n}\n\nexports.__filter = __filter;\nvar filter = /*#__PURE__*/iterableCurry(__filter);\nexports.filter = filter;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$peekerate/async-peekerate.js'),\n    __asyncPeekerate = _require2.__asyncPeekerate;\n\nfunction __asyncFindBestOr(_x, _x2, _x3) {\n  return _asyncFindBestOr.apply(this, arguments);\n}\n\nfunction _asyncFindBestOr() {\n  _asyncFindBestOr = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, notFoundValue, comparer) {\n    var mapper,\n        peekr,\n        best,\n        bestValue,\n        candidate,\n        candidateValue,\n        _args = arguments;\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            mapper = _args.length > 3 && _args[3] !== undefined ? _args[3] : function (value) {\n              return value;\n            };\n            _context.next = 3;\n            return __asyncPeekerate(iterable);\n\n          case 3:\n            peekr = _context.sent;\n\n            if (!peekr.done) {\n              _context.next = 8;\n              break;\n            }\n\n            return _context.abrupt(\"return\", notFoundValue);\n\n          case 8:\n            best = peekr.value;\n            _context.next = 11;\n            return mapper(best, peekr.index);\n\n          case 11:\n            bestValue = _context.sent;\n            _context.next = 14;\n            return peekr.advance();\n\n          case 14:\n            if (peekr.done) {\n              _context.next = 24;\n              break;\n            }\n\n            candidate = peekr.value;\n            _context.next = 18;\n            return mapper(candidate, peekr.index);\n\n          case 18:\n            candidateValue = _context.sent;\n\n            if (comparer(bestValue, candidateValue)) {\n              best = candidate;\n              bestValue = candidateValue;\n            }\n\n            _context.next = 22;\n            return peekr.advance();\n\n          case 22:\n            _context.next = 14;\n            break;\n\n          case 24:\n            return _context.abrupt(\"return\", best);\n\n          case 25:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncFindBestOr.apply(this, arguments);\n}\n\nexports.__asyncFindBestOr = __asyncFindBestOr;\nvar asyncFindBestOr = asyncIterableCurry(__asyncFindBestOr, {\n  reduces: true,\n  minArgs: 2,\n  maxArgs: 3,\n  growRight: true\n});\nexports.asyncFindBestOr = asyncFindBestOr;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$peekerate/peekerate.js'),\n    __peekerate = _require2.__peekerate;\n\nfunction __findBestOr(iterable, notFoundValue, comparer) {\n  var mapper = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : function (value) {\n    return value;\n  };\n\n  var peekr = __peekerate(iterable);\n\n  if (peekr.done) {\n    return notFoundValue;\n  } else {\n    var best = peekr.value;\n    var bestValue = mapper(best, peekr.index);\n    peekr.advance();\n\n    while (!peekr.done) {\n      var candidate = peekr.value;\n      var candidateValue = mapper(candidate, peekr.index);\n\n      if (comparer(bestValue, candidateValue)) {\n        best = candidate;\n        bestValue = candidateValue;\n      }\n\n      peekr.advance();\n    }\n\n    return best;\n  }\n}\n\nexports.__findBestOr = __findBestOr;\nvar findBestOr = iterableCurry(__findBestOr, {\n  reduces: true,\n  minArgs: 2,\n  maxArgs: 3,\n  growRight: true\n});\nexports.findBestOr = findBestOr;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$find-best-or/async-find-best-or.js'),\n    __asyncFindBestOr = _require2.__asyncFindBestOr;\n\nfunction __asyncFindBest(_x, _x2) {\n  return _asyncFindBest.apply(this, arguments);\n}\n\nfunction _asyncFindBest() {\n  _asyncFindBest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, comparer) {\n    var mapper,\n        _args = arguments;\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            mapper = _args.length > 2 && _args[2] !== undefined ? _args[2] : function (value) {\n              return value;\n            };\n            _context.next = 3;\n            return __asyncFindBestOr(iterable, undefined, comparer, mapper);\n\n          case 3:\n            return _context.abrupt(\"return\", _context.sent);\n\n          case 4:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncFindBest.apply(this, arguments);\n}\n\nexports.__asyncFindBest = __asyncFindBest;\nvar asyncFindBest = asyncIterableCurry(__asyncFindBest, {\n  reduces: true,\n  minArgs: 1,\n  maxArgs: 2,\n  growRight: true\n});\nexports.asyncFindBest = asyncFindBest;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$find-best-or/find-best-or.js'),\n    __findBestOr = _require2.__findBestOr;\n\nfunction __findBest(iterable, comparer) {\n  var mapper = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function (value) {\n    return value;\n  };\n  return __findBestOr(iterable, undefined, comparer, mapper);\n}\n\nexports.__findBest = __findBest;\nvar findBest = iterableCurry(__findBest, {\n  reduces: true,\n  minArgs: 1,\n  maxArgs: 2,\n  growRight: true\n});\nexports.findBest = findBest;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nfunction __asyncFindOr(_x, _x2, _x3) {\n  return _asyncFindOr.apply(this, arguments);\n}\n\nfunction _asyncFindOr() {\n  _asyncFindOr = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, notFoundValue, func) {\n    var c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            c = 0;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 3;\n            _iterator = _asyncIterator(iterable);\n\n          case 5:\n            _context.next = 7;\n            return _iterator.next();\n\n          case 7:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 11;\n            return _step.value;\n\n          case 11:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 21;\n              break;\n            }\n\n            value = _value;\n            _context.next = 16;\n            return func(value, c++);\n\n          case 16:\n            if (!_context.sent) {\n              _context.next = 18;\n              break;\n            }\n\n            return _context.abrupt(\"return\", value);\n\n          case 18:\n            _iteratorNormalCompletion = true;\n            _context.next = 5;\n            break;\n\n          case 21:\n            _context.next = 27;\n            break;\n\n          case 23:\n            _context.prev = 23;\n            _context.t0 = _context[\"catch\"](3);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 27:\n            _context.prev = 27;\n            _context.prev = 28;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 32;\n              break;\n            }\n\n            _context.next = 32;\n            return _iterator[\"return\"]();\n\n          case 32:\n            _context.prev = 32;\n\n            if (!_didIteratorError) {\n              _context.next = 35;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 35:\n            return _context.finish(32);\n\n          case 36:\n            return _context.finish(27);\n\n          case 37:\n            return _context.abrupt(\"return\", notFoundValue);\n\n          case 38:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[3, 23, 27, 37], [28,, 32, 36]]);\n  }));\n  return _asyncFindOr.apply(this, arguments);\n}\n\nexports.__asyncFindOr = __asyncFindOr;\nvar asyncFindOr = /*#__PURE__*/asyncIterableCurry(__asyncFindOr, {\n  growRight: true,\n  reduces: true\n});\nexports.asyncFindOr = asyncFindOr;","function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nfunction __findOr(iterable, notFoundValue, func) {\n  var c = 0;\n\n  var _iterator = _createForOfIteratorHelper(iterable),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var value = _step.value;\n\n      if (func(value, c++)) {\n        return value;\n      }\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  return notFoundValue;\n}\n\nexports.__findOr = __findOr;\nvar findOr = /*#__PURE__*/iterableCurry(__findOr, {\n  growRight: true,\n  reduces: true\n});\nexports.findOr = findOr;","var _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$find-or/async-find-or.js'),\n    __asyncFindOr = _require2.__asyncFindOr;\n\nfunction __asyncFind(iterable, predicate) {\n  return __asyncFindOr(iterable, undefined, predicate);\n}\n\nexports.__asyncFind = __asyncFind;\nvar asyncFind = /*#__PURE__*/asyncIterableCurry(__asyncFind, {\n  reduces: true\n});\nexports.asyncFind = asyncFind;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$find-or/find-or.js'),\n    __findOr = _require2.__findOr;\n\nfunction __find(iterable, predicate) {\n  return __findOr(iterable, undefined, predicate);\n}\n\nexports.__find = __find;\nvar find = /*#__PURE__*/iterableCurry(__find, {\n  reduces: true\n});\nexports.find = find;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry,\n    asyncCallReturn = _require.asyncCallReturn;\n\nfunction __asyncFirstOr(_x, _x2) {\n  return _asyncFirstOr.apply(this, arguments);\n}\n\nfunction _asyncFirstOr() {\n  _asyncFirstOr = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, whenEmpty) {\n    var iter, _yield$iter$next, value, done;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            iter = iterable[Symbol.asyncIterator]();\n            _context.next = 3;\n            return iter.next();\n\n          case 3:\n            _yield$iter$next = _context.sent;\n            value = _yield$iter$next.value;\n            done = _yield$iter$next.done;\n\n            if (!done) {\n              _context.next = 8;\n              break;\n            }\n\n            return _context.abrupt(\"return\", whenEmpty);\n\n          case 8:\n            _context.next = 10;\n            return asyncCallReturn(iter);\n\n          case 10:\n            return _context.abrupt(\"return\", value);\n\n          case 11:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncFirstOr.apply(this, arguments);\n}\n\nexports.__asyncFirstOr = __asyncFirstOr;\nvar asyncFirstOr = /*#__PURE__*/asyncIterableCurry(__asyncFirstOr, {\n  reduces: true\n});\nexports.asyncFirstOr = asyncFirstOr;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry,\n    callReturn = _require.callReturn;\n\nfunction __firstOr(iterable, whenEmpty) {\n  var iter = iterable[Symbol.iterator]();\n\n  var _iter$next = iter.next(),\n      value = _iter$next.value,\n      done = _iter$next.done;\n\n  if (done) return whenEmpty;\n  callReturn(iter);\n  return value;\n}\n\nexports.__firstOr = __firstOr;\nvar firstOr = /*#__PURE__*/iterableCurry(__firstOr, {\n  reduces: true\n});\nexports.firstOr = firstOr;","var _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$first-or/async-first-or.js'),\n    __asyncFirstOr = _require2.__asyncFirstOr;\n\nfunction __asyncFirst(iterable) {\n  return __asyncFirstOr(iterable, undefined);\n}\n\nexports.__asyncFirst = __asyncFirst;\nvar asyncFirst = /*#__PURE__*/asyncIterableCurry(__asyncFirst, {\n  reduces: true\n});\nexports.asyncFirst = asyncFirst;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$first-or/first-or.js'),\n    __firstOr = _require2.__firstOr;\n\nfunction __first(iterable) {\n  return __firstOr(iterable, undefined);\n}\n\nexports.__first = __first;\nvar first = /*#__PURE__*/iterableCurry(__first, {\n  reduces: true\n});\nexports.first = first;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _asyncGeneratorDelegate = require(\"@babel/runtime/helpers/asyncGeneratorDelegate\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$map/async-map.js'),\n    __asyncMap = _require2.__asyncMap;\n\nfunction __asyncFlatMap(_x, _x2) {\n  return _asyncFlatMap.apply(this, arguments);\n}\n\nexports.__asyncFlatMap = __asyncFlatMap;\n\nfunction _asyncFlatMap() {\n  _asyncFlatMap = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, func) {\n    var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 2;\n            _iterator = _asyncIterator(__asyncMap(source, func));\n\n          case 4:\n            _context.next = 6;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 6:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 10;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 10:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 17;\n              break;\n            }\n\n            value = _value;\n            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(value), _awaitAsyncGenerator), \"t0\", 14);\n\n          case 14:\n            _iteratorNormalCompletion = true;\n            _context.next = 4;\n            break;\n\n          case 17:\n            _context.next = 23;\n            break;\n\n          case 19:\n            _context.prev = 19;\n            _context.t1 = _context[\"catch\"](2);\n            _didIteratorError = true;\n            _iteratorError = _context.t1;\n\n          case 23:\n            _context.prev = 23;\n            _context.prev = 24;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 28;\n              break;\n            }\n\n            _context.next = 28;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 28:\n            _context.prev = 28;\n\n            if (!_didIteratorError) {\n              _context.next = 31;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 31:\n            return _context.finish(28);\n\n          case 32:\n            return _context.finish(23);\n\n          case 33:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[2, 19, 23, 33], [24,, 28, 32]]);\n  }));\n  return _asyncFlatMap.apply(this, arguments);\n}\n\nvar asyncFlatMap = /*#__PURE__*/asyncIterableCurry(__asyncFlatMap);\nexports.asyncFlatMap = asyncFlatMap;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__flatMap);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$map/map.js'),\n    __map = _require2.__map;\n\nfunction __flatMap(source, func) {\n  var _iterator, _step, value;\n\n  return _regeneratorRuntime.wrap(function __flatMap$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          _iterator = _createForOfIteratorHelper(__map(source, func));\n          _context.prev = 1;\n\n          _iterator.s();\n\n        case 3:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 8;\n            break;\n          }\n\n          value = _step.value;\n          return _context.delegateYield(value, \"t0\", 6);\n\n        case 6:\n          _context.next = 3;\n          break;\n\n        case 8:\n          _context.next = 13;\n          break;\n\n        case 10:\n          _context.prev = 10;\n          _context.t1 = _context[\"catch\"](1);\n\n          _iterator.e(_context.t1);\n\n        case 13:\n          _context.prev = 13;\n\n          _iterator.f();\n\n          return _context.finish(13);\n\n        case 16:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[1, 10, 13, 16]]);\n}\n\nexports.__flatMap = __flatMap;\nvar flatMap = /*#__PURE__*/iterableCurry(__flatMap);\nexports.flatMap = flatMap;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _asyncGeneratorDelegate = require(\"@babel/runtime/helpers/asyncGeneratorDelegate\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry,\n    asyncIsLoopable = _require.asyncIsLoopable;\n\nvar _require2 = require('./internal/validate-args.js'),\n    validateArgs = _require2.validateArgs;\n\nvar defaultShouldFlat = function defaultShouldFlat(value) {\n  return typeof value !== 'string' && asyncIsLoopable(value);\n};\n\nfunction asyncFlatInternal(_x, _x2, _x3, _x4) {\n  return _asyncFlatInternal.apply(this, arguments);\n}\n\nfunction _asyncFlatInternal() {\n  _asyncFlatInternal = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(shouldFlat, depth, currentDepth, source) {\n    var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 2;\n            _iterator = _asyncIterator(source);\n\n          case 4:\n            _context.next = 6;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 6:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 10;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 10:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 27;\n              break;\n            }\n\n            value = _value;\n            _context.t0 = currentDepth < depth;\n\n            if (!_context.t0) {\n              _context.next = 18;\n              break;\n            }\n\n            _context.next = 17;\n            return _awaitAsyncGenerator(shouldFlat(value));\n\n          case 17:\n            _context.t0 = _context.sent;\n\n          case 18:\n            if (!_context.t0) {\n              _context.next = 22;\n              break;\n            }\n\n            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(asyncFlatInternal(shouldFlat, depth, currentDepth + 1, value)), _awaitAsyncGenerator), \"t1\", 20);\n\n          case 20:\n            _context.next = 24;\n            break;\n\n          case 22:\n            _context.next = 24;\n            return value;\n\n          case 24:\n            _iteratorNormalCompletion = true;\n            _context.next = 4;\n            break;\n\n          case 27:\n            _context.next = 33;\n            break;\n\n          case 29:\n            _context.prev = 29;\n            _context.t2 = _context[\"catch\"](2);\n            _didIteratorError = true;\n            _iteratorError = _context.t2;\n\n          case 33:\n            _context.prev = 33;\n            _context.prev = 34;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 38;\n              break;\n            }\n\n            _context.next = 38;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 38:\n            _context.prev = 38;\n\n            if (!_didIteratorError) {\n              _context.next = 41;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 41:\n            return _context.finish(38);\n\n          case 42:\n            return _context.finish(33);\n\n          case 43:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[2, 29, 33, 43], [34,, 38, 42]]);\n  }));\n  return _asyncFlatInternal.apply(this, arguments);\n}\n\nfunction __asyncFlat(source) {\n  var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;\n  var shouldFlat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultShouldFlat;\n  return asyncFlatInternal(shouldFlat, depth, 0, source);\n}\n\nexports.__asyncFlat = __asyncFlat;\nvar asyncFlat = /*#__PURE__*/asyncIterableCurry(__asyncFlat, {\n  minArgs: 0,\n  maxArgs: 2,\n  validateArgs: validateArgs\n});\nexports.asyncFlat = asyncFlat;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(flatInternal);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry,\n    isLoopable = _require.isLoopable;\n\nvar _require2 = require('./internal/validate-args.js'),\n    validateArgs = _require2.validateArgs;\n\nvar defaultShouldFlat = function defaultShouldFlat(value) {\n  return typeof value !== 'string' && isLoopable(value);\n};\n\nfunction flatInternal(shouldFlat, depth, currentDepth, source) {\n  var _iterator, _step, value;\n\n  return _regeneratorRuntime.wrap(function flatInternal$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          _iterator = _createForOfIteratorHelper(source);\n          _context.prev = 1;\n\n          _iterator.s();\n\n        case 3:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 13;\n            break;\n          }\n\n          value = _step.value;\n\n          if (!(currentDepth < depth && shouldFlat(value))) {\n            _context.next = 9;\n            break;\n          }\n\n          return _context.delegateYield(flatInternal(shouldFlat, depth, currentDepth + 1, value), \"t0\", 7);\n\n        case 7:\n          _context.next = 11;\n          break;\n\n        case 9:\n          _context.next = 11;\n          return value;\n\n        case 11:\n          _context.next = 3;\n          break;\n\n        case 13:\n          _context.next = 18;\n          break;\n\n        case 15:\n          _context.prev = 15;\n          _context.t1 = _context[\"catch\"](1);\n\n          _iterator.e(_context.t1);\n\n        case 18:\n          _context.prev = 18;\n\n          _iterator.f();\n\n          return _context.finish(18);\n\n        case 21:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[1, 15, 18, 21]]);\n}\n\nfunction __flat(source) {\n  var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;\n  var shouldFlat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultShouldFlat;\n  return flatInternal(shouldFlat, depth, 0, source);\n}\n\nexports.__flat = __flat;\nvar flat = /*#__PURE__*/iterableCurry(__flat, {\n  minArgs: 0,\n  maxArgs: 2,\n  validateArgs: validateArgs\n});\nexports.flat = flat;","var _require = require('../../is-object/is-object.js'),\n    isObject = _require.isObject;\n\nfunction validateArgs(args) {\n  var depthOrOptions = args[1];\n  var shouldFlat = args[2];\n  var depth = depthOrOptions;\n\n  if (isObject(depthOrOptions)) {\n    shouldFlat = depthOrOptions.shouldFlat;\n    depth = depthOrOptions.depth;\n  }\n\n  args[2] = shouldFlat;\n  args[1] = depth;\n}\n\nexports.validateArgs = validateArgs;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nfunction __asyncForEach(_x, _x2) {\n  return _asyncForEach.apply(this, arguments);\n}\n\nfunction _asyncForEach() {\n  _asyncForEach = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, callback) {\n    var c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            c = 0;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 3;\n            _iterator = _asyncIterator(iterable);\n\n          case 5:\n            _context.next = 7;\n            return _iterator.next();\n\n          case 7:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 11;\n            return _step.value;\n\n          case 11:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 19;\n              break;\n            }\n\n            value = _value;\n            _context.next = 16;\n            return callback(value, c++);\n\n          case 16:\n            _iteratorNormalCompletion = true;\n            _context.next = 5;\n            break;\n\n          case 19:\n            _context.next = 25;\n            break;\n\n          case 21:\n            _context.prev = 21;\n            _context.t0 = _context[\"catch\"](3);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 25:\n            _context.prev = 25;\n            _context.prev = 26;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 30;\n              break;\n            }\n\n            _context.next = 30;\n            return _iterator[\"return\"]();\n\n          case 30:\n            _context.prev = 30;\n\n            if (!_didIteratorError) {\n              _context.next = 33;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 33:\n            return _context.finish(30);\n\n          case 34:\n            return _context.finish(25);\n\n          case 35:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[3, 21, 25, 35], [26,, 30, 34]]);\n  }));\n  return _asyncForEach.apply(this, arguments);\n}\n\nexports.__asyncForEach = __asyncForEach;\nvar asyncForEach = /*#__PURE__*/asyncIterableCurry(__asyncForEach, {\n  reduces: true\n});\nexports.asyncForEach = asyncForEach;","function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nfunction __forEach(iterable, callback) {\n  var c = 0;\n\n  var _iterator = _createForOfIteratorHelper(iterable),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var value = _step.value;\n      callback(value, c++);\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n}\n\nexports.__forEach = __forEach;\nvar forEach = /*#__PURE__*/iterableCurry(__forEach, {\n  reduces: true\n});\nexports.forEach = forEach;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__asyncFork);\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../../internal/async-fork.js'),\n    AsyncExchange = _require2.AsyncExchange;\n\nfunction __asyncFork(source) {\n  var exchange, dummyFork;\n  return _regeneratorRuntime.wrap(function __asyncFork$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          exchange = new AsyncExchange(source[Symbol.asyncIterator]());\n          dummyFork = exchange.fork();\n          _context.prev = 2;\n\n        case 3:\n          if (!true) {\n            _context.next = 8;\n            break;\n          }\n\n          _context.next = 6;\n          return exchange.fork();\n\n        case 6:\n          _context.next = 3;\n          break;\n\n        case 8:\n          _context.prev = 8;\n          dummyFork[\"return\"]();\n          return _context.finish(8);\n\n        case 11:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[2,, 8, 11]]);\n}\n\nexports.__asyncFork = __asyncFork;\nvar asyncFork = /*#__PURE__*/asyncIterableCurry(__asyncFork, {\n  forceSync: true\n});\nexports.asyncFork = asyncFork;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__fork);\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../../internal/fork.js'),\n    Exchange = _require2.Exchange;\n\nfunction __fork(source) {\n  var exchange, dummyFork;\n  return _regeneratorRuntime.wrap(function __fork$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          exchange = new Exchange(source[Symbol.iterator]());\n          dummyFork = exchange.fork();\n          _context.prev = 2;\n\n        case 3:\n          if (!true) {\n            _context.next = 8;\n            break;\n          }\n\n          _context.next = 6;\n          return exchange.fork();\n\n        case 6:\n          _context.next = 3;\n          break;\n\n        case 8:\n          _context.prev = 8;\n          dummyFork[\"return\"]();\n          return _context.finish(8);\n\n        case 11:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[2,, 8, 11]]);\n}\n\nexports.__fork = __fork;\nvar fork = /*#__PURE__*/iterableCurry(__fork, {\n  forceSync: true\n});\nexports.fork = fork;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar _inherits = require(\"@babel/runtime/helpers/inherits\");\n\nvar _possibleConstructorReturn = require(\"@babel/runtime/helpers/possibleConstructorReturn\");\n\nvar _get = require(\"@babel/runtime/helpers/get\");\n\nvar _getPrototypeOf = require(\"@babel/runtime/helpers/getPrototypeOf\");\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncEnsureIterable = _require.asyncEnsureIterable;\n\nvar _require2 = require('../../internal/async-fork.js'),\n    AsyncExchange = _require2.AsyncExchange;\n\nvar _require3 = require('../../internal/async-peekerator.js'),\n    AsyncPeekerator = _require3.AsyncPeekerator;\n\nvar _ = Symbol[\"for\"]('_');\n\nvar AsyncForkerator = /*#__PURE__*/function (_AsyncPeekerator) {\n  _inherits(AsyncForkerator, _AsyncPeekerator);\n\n  var _super = _createSuper(AsyncForkerator);\n\n  _createClass(AsyncForkerator, null, [{\n    key: \"from\",\n    value: function () {\n      var _from = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source) {\n        var exchange;\n        return _regeneratorRuntime.wrap(function _callee$(_context) {\n          while (1) {\n            switch (_context.prev = _context.next) {\n              case 0:\n                exchange = new AsyncExchange(asyncEnsureIterable(source)[Symbol.asyncIterator]());\n                _context.next = 3;\n                return _get(_getPrototypeOf(AsyncForkerator), \"from\", this).call(this, exchange.fork(), exchange);\n\n              case 3:\n                return _context.abrupt(\"return\", _context.sent);\n\n              case 4:\n              case \"end\":\n                return _context.stop();\n            }\n          }\n        }, _callee, this);\n      }));\n\n      function from(_x) {\n        return _from.apply(this, arguments);\n      }\n\n      return from;\n    }()\n  }]);\n\n  function AsyncForkerator(iterator, first, exchange) {\n    var _this;\n\n    _classCallCheck(this, AsyncForkerator);\n\n    _this = _super.call(this, iterator, first);\n    _this[_].exchange = exchange;\n    return _this;\n  }\n\n  _createClass(AsyncForkerator, [{\n    key: \"advance\",\n    value: function () {\n      var _advance = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {\n        var n,\n            i,\n            _args2 = arguments;\n        return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n          while (1) {\n            switch (_context2.prev = _context2.next) {\n              case 0:\n                n = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : 1;\n                i = 0;\n\n              case 2:\n                if (!(i < n)) {\n                  _context2.next = 9;\n                  break;\n                }\n\n                _context2.next = 5;\n                return _get(_getPrototypeOf(AsyncForkerator.prototype), \"advance\", this).call(this);\n\n              case 5:\n                this[_].exchange.advance();\n\n              case 6:\n                i++;\n                _context2.next = 2;\n                break;\n\n              case 9:\n                return _context2.abrupt(\"return\", this);\n\n              case 10:\n              case \"end\":\n                return _context2.stop();\n            }\n          }\n        }, _callee2, this);\n      }));\n\n      function advance() {\n        return _advance.apply(this, arguments);\n      }\n\n      return advance;\n    }()\n  }, {\n    key: \"fork\",\n    value: function fork() {\n      return this[_].exchange.fork();\n    }\n  }, {\n    key: Symbol.asyncIterator,\n    value: function value() {\n      return this[_].exchange.fork();\n    }\n  }]);\n\n  return AsyncForkerator;\n}(AsyncPeekerator);\n\nfunction __asyncForkerate(source) {\n  return AsyncForkerator.from(source);\n}\n\nexports.__asyncForkerate = __asyncForkerate;\n\nfunction asyncWrapWithEnsureIterable(fn) {\n  return function (source) {\n    return fn(asyncEnsureIterable(source));\n  };\n}\n\nvar asyncForkerate = asyncWrapWithEnsureIterable(__asyncForkerate);\nexports.asyncForkerate = asyncForkerate;","var _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar _inherits = require(\"@babel/runtime/helpers/inherits\");\n\nvar _possibleConstructorReturn = require(\"@babel/runtime/helpers/possibleConstructorReturn\");\n\nvar _get = require(\"@babel/runtime/helpers/get\");\n\nvar _getPrototypeOf = require(\"@babel/runtime/helpers/getPrototypeOf\");\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nvar _require = require('../../internal/iterable.js'),\n    ensureIterable = _require.ensureIterable;\n\nvar _require2 = require('../../internal/fork.js'),\n    Exchange = _require2.Exchange;\n\nvar _require3 = require('../../internal/peekerator.js'),\n    Peekerator = _require3.Peekerator;\n\nvar _ = Symbol[\"for\"]('_');\n\nvar Forkerator = /*#__PURE__*/function (_Peekerator) {\n  _inherits(Forkerator, _Peekerator);\n\n  var _super = _createSuper(Forkerator);\n\n  _createClass(Forkerator, null, [{\n    key: \"from\",\n    value: function from(source) {\n      var exchange = new Exchange(ensureIterable(source)[Symbol.iterator]());\n      return _get(_getPrototypeOf(Forkerator), \"from\", this).call(this, exchange.fork(), exchange);\n    }\n  }]);\n\n  function Forkerator(iterator, first, exchange) {\n    var _this;\n\n    _classCallCheck(this, Forkerator);\n\n    _this = _super.call(this, iterator, first);\n    _this[_].exchange = exchange;\n    return _this;\n  }\n\n  _createClass(Forkerator, [{\n    key: \"advance\",\n    value: function advance() {\n      var n = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;\n\n      for (var i = 0; i < n; i++) {\n        _get(_getPrototypeOf(Forkerator.prototype), \"advance\", this).call(this);\n\n        this[_].exchange.advance();\n      }\n\n      return this;\n    }\n  }, {\n    key: \"fork\",\n    value: function fork() {\n      return this[_].exchange.fork();\n    }\n  }, {\n    key: Symbol.iterator,\n    value: function value() {\n      return this[_].exchange.fork();\n    }\n  }]);\n\n  return Forkerator;\n}(Peekerator);\n\nfunction __forkerate(source) {\n  return Forkerator.from(source);\n}\n\nexports.__forkerate = __forkerate;\n\nfunction wrapWithEnsureIterable(fn) {\n  return function (source) {\n    return fn(ensureIterable(source));\n  };\n}\n\nvar forkerate = wrapWithEnsureIterable(__forkerate);\nexports.forkerate = forkerate;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../../internal/async-any-seq.js'),\n    asyncSeqsToArray = _require2.asyncSeqsToArray;\n\nvar _require3 = require('../$window-ahead/async-window-ahead.js'),\n    __asyncWindowAhead = _require3.__asyncWindowAhead;\n\nvar _require4 = require('../$starts-with-any-seq/starts-with-any-seq.js'),\n    __startsWithAnySeq = _require4.__startsWithAnySeq;\n\nfunction __asyncIncludesAnySeq(_x, _x2) {\n  return _asyncIncludesAnySeq.apply(this, arguments);\n}\n\nfunction _asyncIncludesAnySeq() {\n  _asyncIncludesAnySeq = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, seqs) {\n    var same,\n        seqsArr,\n        maxMatchLength,\n        _iteratorNormalCompletion,\n        _didIteratorError,\n        _iteratorError,\n        _iterator,\n        _step,\n        _value,\n        buffer,\n        _args = arguments;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            same = _args.length > 2 && _args[2] !== undefined ? _args[2] : Object.is;\n            _context.next = 3;\n            return asyncSeqsToArray(seqs);\n\n          case 3:\n            seqsArr = _context.sent;\n\n            if (seqsArr.length) {\n              _context.next = 6;\n              break;\n            }\n\n            return _context.abrupt(\"return\", false);\n\n          case 6:\n            if (!seqsArr.find(function (seq) {\n              return !seq.length;\n            })) {\n              _context.next = 8;\n              break;\n            }\n\n            return _context.abrupt(\"return\", true);\n\n          case 8:\n            maxMatchLength = seqsArr.reduce(function (max, _ref) {\n              var length = _ref.length;\n              return Math.max(max, length);\n            }, 1);\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 11;\n            _iterator = _asyncIterator(__asyncWindowAhead(iterable, maxMatchLength));\n\n          case 13:\n            _context.next = 15;\n            return _iterator.next();\n\n          case 15:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 19;\n            return _step.value;\n\n          case 19:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 27;\n              break;\n            }\n\n            buffer = _value;\n\n            if (!__startsWithAnySeq(buffer, seqsArr, same)) {\n              _context.next = 24;\n              break;\n            }\n\n            return _context.abrupt(\"return\", true);\n\n          case 24:\n            _iteratorNormalCompletion = true;\n            _context.next = 13;\n            break;\n\n          case 27:\n            _context.next = 33;\n            break;\n\n          case 29:\n            _context.prev = 29;\n            _context.t0 = _context[\"catch\"](11);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 33:\n            _context.prev = 33;\n            _context.prev = 34;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 38;\n              break;\n            }\n\n            _context.next = 38;\n            return _iterator[\"return\"]();\n\n          case 38:\n            _context.prev = 38;\n\n            if (!_didIteratorError) {\n              _context.next = 41;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 41:\n            return _context.finish(38);\n\n          case 42:\n            return _context.finish(33);\n\n          case 43:\n            return _context.abrupt(\"return\", false);\n\n          case 44:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[11, 29, 33, 43], [34,, 38, 42]]);\n  }));\n  return _asyncIncludesAnySeq.apply(this, arguments);\n}\n\nexports.__asyncIncludesAnySeq = __asyncIncludesAnySeq;\nvar asyncIncludesAnySeq = /*#__PURE__*/asyncIterableCurry(__asyncIncludesAnySeq, {\n  minArgs: 1,\n  maxArgs: 2,\n  reduces: true\n});\nexports.asyncIncludesAnySeq = asyncIncludesAnySeq;","function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../../internal/any-seq.js'),\n    seqsToArray = _require2.seqsToArray;\n\nvar _require3 = require('../$window-ahead/window-ahead.js'),\n    __windowAhead = _require3.__windowAhead;\n\nvar _require4 = require('../$starts-with-any-seq/starts-with-any-seq.js'),\n    __startsWithAnySeq = _require4.__startsWithAnySeq;\n\nfunction __includesAnySeq(iterable, seqs) {\n  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;\n  var seqsArr = seqsToArray(seqs);\n  if (!seqsArr.length) return false;\n  if (seqsArr.find(function (seq) {\n    return !seq.length;\n  })) return true;\n  var maxMatchLength = seqsArr.reduce(function (max, _ref) {\n    var length = _ref.length;\n    return Math.max(max, length);\n  }, 1);\n\n  var _iterator = _createForOfIteratorHelper(__windowAhead(iterable, maxMatchLength)),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var buffer = _step.value;\n\n      if (__startsWithAnySeq(buffer, seqsArr, same)) {\n        return true;\n      }\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  return false;\n}\n\nexports.__includesAnySeq = __includesAnySeq;\nvar includesAnySeq = /*#__PURE__*/iterableCurry(__includesAnySeq, {\n  minArgs: 1,\n  maxArgs: 2,\n  reduces: true\n});\nexports.includesAnySeq = includesAnySeq;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$find-or/async-find-or.js'),\n    __asyncFindOr = _require2.__asyncFindOr;\n\nvar _require3 = require('../$includes/includes.js'),\n    __includes = _require3.__includes;\n\nvar none = Symbol('none');\n\nfunction __asyncIncludesAny(_x, _x2) {\n  return _asyncIncludesAny.apply(this, arguments);\n}\n\nfunction _asyncIncludesAny() {\n  _asyncIncludesAny = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, values) {\n    var same,\n        _args = arguments;\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            same = _args.length > 2 && _args[2] !== undefined ? _args[2] : Object.is;\n            _context.next = 3;\n            return __asyncFindOr(iterable, none, function (value) {\n              return __includes(values, value, function (a, b) {\n                return same(b, a);\n              });\n            });\n\n          case 3:\n            _context.t0 = _context.sent;\n            _context.t1 = none;\n            return _context.abrupt(\"return\", _context.t0 !== _context.t1);\n\n          case 6:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncIncludesAny.apply(this, arguments);\n}\n\nexports.__asyncIncludesAny = __asyncIncludesAny;\nvar asyncIncludesAny = /*#__PURE__*/asyncIterableCurry(__asyncIncludesAny, {\n  minArgs: 1,\n  maxArgs: 2,\n  reduces: true,\n  validateArgs: function validateArgs(args) {}\n});\nexports.asyncIncludesAny = asyncIncludesAny;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$find-or/find-or.js'),\n    __findOr = _require2.__findOr;\n\nvar _require3 = require('../$includes/includes.js'),\n    __includes = _require3.__includes;\n\nvar none = Symbol('none');\n\nfunction __includesAny(iterable, values) {\n  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;\n  return __findOr(iterable, none, function (value) {\n    return __includes(values, value, function (a, b) {\n      return same(b, a);\n    });\n  }) !== none;\n}\n\nexports.__includesAny = __includesAny;\nvar includesAny = /*#__PURE__*/iterableCurry(__includesAny, {\n  minArgs: 1,\n  maxArgs: 2,\n  reduces: true,\n  validateArgs: function validateArgs(args) {\n    if (true && typeof args[0] === 'string') {\n      console.warn(\"For string inputs use includesAnySeq instead of includesAny\");\n    }\n  }\n});\nexports.includesAny = includesAny;","var _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry,\n    asyncEnsureIterable = _require.asyncEnsureIterable;\n\nvar _require2 = require('../$includes-any-seq/async-includes-any-seq.js'),\n    __asyncIncludesAnySeq = _require2.__asyncIncludesAnySeq;\n\nfunction __asyncIncludesSeq(iterable, seq) {\n  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;\n  return __asyncIncludesAnySeq(iterable, [seq], same);\n}\n\nexports.__asyncIncludesSeq = __asyncIncludesSeq;\nvar asyncIncludesSeq = /*#__PURE__*/asyncIterableCurry(__asyncIncludesSeq, {\n  minArgs: 1,\n  maxArgs: 2,\n  reduces: true,\n  validateArgs: function validateArgs(args) {\n    args[1] = asyncEnsureIterable(args[1]);\n  }\n});\nexports.asyncIncludesSeq = asyncIncludesSeq;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry,\n    ensureIterable = _require.ensureIterable;\n\nvar _require2 = require('../$includes-any-seq/includes-any-seq.js'),\n    __includesAnySeq = _require2.__includesAnySeq;\n\nfunction __includesSeq(iterable, seq) {\n  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;\n  return __includesAnySeq(iterable, [seq], same);\n}\n\nexports.__includesSeq = __includesSeq;\nvar includesSeq = /*#__PURE__*/iterableCurry(__includesSeq, {\n  minArgs: 1,\n  maxArgs: 2,\n  reduces: true,\n  validateArgs: function validateArgs(args) {\n    args[1] = ensureIterable(args[1]);\n  }\n});\nexports.includesSeq = includesSeq;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$find-or/async-find-or.js'),\n    __asyncFindOr = _require2.__asyncFindOr;\n\nvar none = Symbol('none');\n\nfunction __asyncIncludes(_x, _x2) {\n  return _asyncIncludes.apply(this, arguments);\n}\n\nfunction _asyncIncludes() {\n  _asyncIncludes = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, value) {\n    var same,\n        _args = arguments;\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            same = _args.length > 2 && _args[2] !== undefined ? _args[2] : Object.is;\n            _context.next = 3;\n            return __asyncFindOr(iterable, none, function (v) {\n              return same(value, v);\n            });\n\n          case 3:\n            _context.t0 = _context.sent;\n            _context.t1 = none;\n            return _context.abrupt(\"return\", _context.t0 !== _context.t1);\n\n          case 6:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncIncludes.apply(this, arguments);\n}\n\nexports.__asyncIncludes = __asyncIncludes;\nvar asyncIncludes = /*#__PURE__*/asyncIterableCurry(__asyncIncludes, {\n  minArgs: 1,\n  maxArgs: 2,\n  reduces: true,\n  validateArgs: function validateArgs(args) {}\n});\nexports.asyncIncludes = asyncIncludes;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$find-or/find-or.js'),\n    __findOr = _require2.__findOr;\n\nvar none = Symbol('none');\n\nfunction __includes(iterable, value) {\n  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;\n  return __findOr(iterable, none, function (v) {\n    return same(value, v);\n  }) !== none;\n}\n\nexports.__includes = __includes;\nvar includes = /*#__PURE__*/iterableCurry(__includes, {\n  minArgs: 1,\n  maxArgs: 2,\n  reduces: true,\n  validateArgs: function validateArgs(args) {\n    if (true && typeof args[0] === 'string') {\n      console.warn(\"For string inputs use includesSeq instead of includes\");\n    }\n  }\n});\nexports.includes = includes;","var _toConsumableArray = require(\"@babel/runtime/helpers/toConsumableArray\");\n\nvar _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar _get = require(\"@babel/runtime/helpers/get\");\n\nvar _inherits = require(\"@babel/runtime/helpers/inherits\");\n\nvar _possibleConstructorReturn = require(\"@babel/runtime/helpers/possibleConstructorReturn\");\n\nvar _getPrototypeOf = require(\"@babel/runtime/helpers/getPrototypeOf\");\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry,\n    asyncCallReturn = _require.asyncCallReturn;\n\nvar _require2 = require('../../internal/async-iterable-iterator.js'),\n    AsyncIterableIterator = _require2.AsyncIterableIterator;\n\nvar _require3 = require('../../internal/async-parallel-each.js'),\n    asyncParallelEach = _require3.asyncParallelEach;\n\nvar _require4 = require('../../internal/async-peekerator.js'),\n    AsyncPeekerator = _require4.AsyncPeekerator;\n\nvar _require5 = require('../$map/async-map.js'),\n    __asyncMap = _require5.__asyncMap;\n\nvar _require6 = require('../$to-array/async-to-array.js'),\n    __asyncToArray = _require6.__asyncToArray;\n\nvar _ = Symbol[\"for\"]('_');\n\nvar __advance = Symbol[\"for\"]('__advance');\n\nvar AsyncSummarizedPeekerator = /*#__PURE__*/function (_AsyncPeekerator) {\n  _inherits(AsyncSummarizedPeekerator, _AsyncPeekerator);\n\n  var _super = _createSuper(AsyncSummarizedPeekerator);\n\n  function AsyncSummarizedPeekerator(iterator, first, inputSummary) {\n    var _this;\n\n    _classCallCheck(this, AsyncSummarizedPeekerator);\n\n    _this = _super.call(this, iterator, first);\n    _this[_].inputSummary = inputSummary;\n    return _this;\n  }\n\n  _createClass(AsyncSummarizedPeekerator, [{\n    key: \"advance\",\n    value: function () {\n      var _advance = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {\n        return _regeneratorRuntime.wrap(function _callee$(_context) {\n          while (1) {\n            switch (_context.prev = _context.next) {\n              case 0:\n                _context.next = 2;\n                return this[_].inputSummary.advanceBuffer(this);\n\n              case 2:\n              case \"end\":\n                return _context.stop();\n            }\n          }\n        }, _callee, this);\n      }));\n\n      function advance() {\n        return _advance.apply(this, arguments);\n      }\n\n      return advance;\n    }()\n  }, {\n    key: __advance,\n    value: function () {\n      var _value = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {\n        return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n          while (1) {\n            switch (_context2.prev = _context2.next) {\n              case 0:\n                _context2.next = 2;\n                return _get(_getPrototypeOf(AsyncSummarizedPeekerator.prototype), \"advance\", this).call(this);\n\n              case 2:\n              case \"end\":\n                return _context2.stop();\n            }\n          }\n        }, _callee2, this);\n      }));\n\n      function value() {\n        return _value.apply(this, arguments);\n      }\n\n      return value;\n    }()\n  }]);\n\n  return AsyncSummarizedPeekerator;\n}(AsyncPeekerator);\n\nvar AsyncInputSummaryInternal = /*#__PURE__*/function () {\n  function AsyncInputSummaryInternal() {\n    _classCallCheck(this, AsyncInputSummaryInternal);\n\n    this.buffers = [];\n    this.notDoneBuffer = null;\n    this.index = 0;\n  }\n\n  _createClass(AsyncInputSummaryInternal, [{\n    key: \"init\",\n    value: function init(buffers) {\n      this.buffers = buffers;\n      this.updateNotDone();\n    }\n  }, {\n    key: \"updateNotDone\",\n    value: function updateNotDone() {\n      this.notDoneBuffer = this.buffers.find(function (buffer) {\n        return !buffer.done;\n      });\n    }\n  }, {\n    key: \"advanceBuffer\",\n    value: function () {\n      var _advanceBuffer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(buffer) {\n        var wasDone;\n        return _regeneratorRuntime.wrap(function _callee3$(_context3) {\n          while (1) {\n            switch (_context3.prev = _context3.next) {\n              case 0:\n                wasDone = buffer.done;\n                _context3.next = 3;\n                return buffer[__advance]();\n\n              case 3:\n                this.index++;\n\n                if (!wasDone && buffer.done) {\n                  this.updateNotDone();\n                }\n\n              case 5:\n              case \"end\":\n                return _context3.stop();\n            }\n          }\n        }, _callee3, this);\n      }));\n\n      function advanceBuffer(_x) {\n        return _advanceBuffer.apply(this, arguments);\n      }\n\n      return advanceBuffer;\n    }()\n  }]);\n\n  return AsyncInputSummaryInternal;\n}();\n\nvar AsyncInputSummary = /*#__PURE__*/function () {\n  function AsyncInputSummary(internal) {\n    _classCallCheck(this, AsyncInputSummary);\n\n    this[_] = internal;\n  }\n\n  _createClass(AsyncInputSummary, [{\n    key: \"advance\",\n    value: function advance() {\n      throw new Error('advance() is not supported on an interleave summary');\n    }\n  }, {\n    key: \"current\",\n    get: function get() {\n      return {\n        value: this.value,\n        done: this.done\n      };\n    }\n  }, {\n    key: \"value\",\n    get: function get() {\n      return this[_].notDoneBuffer;\n    }\n  }, {\n    key: \"done\",\n    get: function get() {\n      return this[_].notDoneBuffer === undefined;\n    }\n  }, {\n    key: \"index\",\n    get: function get() {\n      return this[_].index;\n    }\n  }]);\n\n  return AsyncInputSummary;\n}();\n\nexports.AsyncInputSummary = AsyncInputSummary;\n\nvar AsyncInterleaver = /*#__PURE__*/function (_AsyncIterableIterato) {\n  _inherits(AsyncInterleaver, _AsyncIterableIterato);\n\n  var _super2 = _createSuper(AsyncInterleaver);\n\n  function AsyncInterleaver(sources, strategy, options) {\n    var _this2;\n\n    _classCallCheck(this, AsyncInterleaver);\n\n    _this2 = _super2.call(this);\n    _this2.sources = sources;\n    _this2.strategy = strategy;\n    _this2.options = options;\n    _this2.initialized = false;\n    _this2.inputSummary = new AsyncInputSummaryInternal(sources);\n    return _this2;\n  }\n\n  _createClass(AsyncInterleaver, [{\n    key: \"init\",\n    value: function () {\n      var _init = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {\n        var strategy, options, inputSummary;\n        return _regeneratorRuntime.wrap(function _callee4$(_context4) {\n          while (1) {\n            switch (_context4.prev = _context4.next) {\n              case 0:\n                this.initialized = true;\n                strategy = this.strategy, options = this.options, inputSummary = this.inputSummary;\n                _context4.next = 4;\n                return __asyncToArray(__asyncMap(this.sources, function (source) {\n                  return AsyncSummarizedPeekerator.from(source, inputSummary);\n                }));\n\n              case 4:\n                this.buffers = _context4.sent;\n                this.iterator = strategy.apply(void 0, [options, new AsyncInputSummary(inputSummary)].concat(_toConsumableArray(this.buffers)));\n                _context4.next = 8;\n                return inputSummary.init(this.buffers);\n\n              case 8:\n              case \"end\":\n                return _context4.stop();\n            }\n          }\n        }, _callee4, this);\n      }));\n\n      function init() {\n        return _init.apply(this, arguments);\n      }\n\n      return init;\n    }()\n  }, {\n    key: \"returnBuffers\",\n    value: function () {\n      var _returnBuffers = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {\n        return _regeneratorRuntime.wrap(function _callee5$(_context5) {\n          while (1) {\n            switch (_context5.prev = _context5.next) {\n              case 0:\n                _context5.next = 2;\n                return asyncParallelEach(this.buffers, function (buffer) {\n                  return buffer[\"return\"]();\n                });\n\n              case 2:\n              case \"end\":\n                return _context5.stop();\n            }\n          }\n        }, _callee5, this);\n      }));\n\n      function returnBuffers() {\n        return _returnBuffers.apply(this, arguments);\n      }\n\n      return returnBuffers;\n    }()\n  }, {\n    key: \"next\",\n    value: function () {\n      var _next = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {\n        var step;\n        return _regeneratorRuntime.wrap(function _callee6$(_context6) {\n          while (1) {\n            switch (_context6.prev = _context6.next) {\n              case 0:\n                if (this.initialized) {\n                  _context6.next = 3;\n                  break;\n                }\n\n                _context6.next = 3;\n                return this.init();\n\n              case 3:\n                _context6.next = 5;\n                return this.iterator.next();\n\n              case 5:\n                step = _context6.sent;\n\n                if (!step.done) {\n                  _context6.next = 9;\n                  break;\n                }\n\n                _context6.next = 9;\n                return this.returnBuffers();\n\n              case 9:\n                return _context6.abrupt(\"return\", step);\n\n              case 10:\n              case \"end\":\n                return _context6.stop();\n            }\n          }\n        }, _callee6, this);\n      }));\n\n      function next() {\n        return _next.apply(this, arguments);\n      }\n\n      return next;\n    }()\n  }, {\n    key: \"return\",\n    value: function () {\n      var _return2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {\n        return _regeneratorRuntime.wrap(function _callee7$(_context7) {\n          while (1) {\n            switch (_context7.prev = _context7.next) {\n              case 0:\n                _context7.next = 2;\n                return asyncCallReturn(this.iterator);\n\n              case 2:\n                _context7.next = 4;\n                return this.returnBuffers();\n\n              case 4:\n                return _context7.abrupt(\"return\", {\n                  value: undefined,\n                  done: true\n                });\n\n              case 5:\n              case \"end\":\n                return _context7.stop();\n            }\n          }\n        }, _callee7, this);\n      }));\n\n      function _return() {\n        return _return2.apply(this, arguments);\n      }\n\n      return _return;\n    }()\n  }]);\n\n  return AsyncInterleaver;\n}(AsyncIterableIterator);\n\nfunction __asyncInterleave(sources, strategy) {\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  return new AsyncInterleaver(sources, strategy, options);\n}\n\nexports.__asyncInterleave = __asyncInterleave;\nvar asyncInterleave = /*#__PURE__*/asyncIterableCurry(__asyncInterleave, {\n  variadic: true,\n  growRight: true,\n  minArgs: 1,\n  maxArgs: 2\n});\nexports.asyncInterleave = asyncInterleave;","var _toConsumableArray = require(\"@babel/runtime/helpers/toConsumableArray\");\n\nvar _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar _get = require(\"@babel/runtime/helpers/get\");\n\nvar _inherits = require(\"@babel/runtime/helpers/inherits\");\n\nvar _possibleConstructorReturn = require(\"@babel/runtime/helpers/possibleConstructorReturn\");\n\nvar _getPrototypeOf = require(\"@babel/runtime/helpers/getPrototypeOf\");\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry,\n    callReturn = _require.callReturn;\n\nvar _require2 = require('../../internal/iterable-iterator.js'),\n    IterableIterator = _require2.IterableIterator;\n\nvar _require3 = require('../../internal/parallel-each.js'),\n    parallelEach = _require3.parallelEach;\n\nvar _require4 = require('../../internal/peekerator.js'),\n    Peekerator = _require4.Peekerator;\n\nvar _require5 = require('../$map/map.js'),\n    __map = _require5.__map;\n\nvar _require6 = require('../$to-array/to-array.js'),\n    __toArray = _require6.__toArray;\n\nvar _ = Symbol[\"for\"]('_');\n\nvar __advance = Symbol[\"for\"]('__advance');\n\nvar SummarizedPeekerator = /*#__PURE__*/function (_Peekerator) {\n  _inherits(SummarizedPeekerator, _Peekerator);\n\n  var _super = _createSuper(SummarizedPeekerator);\n\n  function SummarizedPeekerator(iterator, first, inputSummary) {\n    var _this;\n\n    _classCallCheck(this, SummarizedPeekerator);\n\n    _this = _super.call(this, iterator, first);\n    _this[_].inputSummary = inputSummary;\n    return _this;\n  }\n\n  _createClass(SummarizedPeekerator, [{\n    key: \"advance\",\n    value: function advance() {\n      this[_].inputSummary.advanceBuffer(this);\n    }\n  }, {\n    key: __advance,\n    value: function value() {\n      _get(_getPrototypeOf(SummarizedPeekerator.prototype), \"advance\", this).call(this);\n    }\n  }]);\n\n  return SummarizedPeekerator;\n}(Peekerator);\n\nvar InputSummaryInternal = /*#__PURE__*/function () {\n  function InputSummaryInternal() {\n    _classCallCheck(this, InputSummaryInternal);\n\n    this.buffers = [];\n    this.notDoneBuffer = null;\n    this.index = 0;\n  }\n\n  _createClass(InputSummaryInternal, [{\n    key: \"init\",\n    value: function init(buffers) {\n      this.buffers = buffers;\n      this.updateNotDone();\n    }\n  }, {\n    key: \"updateNotDone\",\n    value: function updateNotDone() {\n      this.notDoneBuffer = this.buffers.find(function (buffer) {\n        return !buffer.done;\n      });\n    }\n  }, {\n    key: \"advanceBuffer\",\n    value: function advanceBuffer(buffer) {\n      var wasDone = buffer.done;\n\n      buffer[__advance]();\n\n      this.index++;\n\n      if (!wasDone && buffer.done) {\n        this.updateNotDone();\n      }\n    }\n  }]);\n\n  return InputSummaryInternal;\n}();\n\nvar InputSummary = /*#__PURE__*/function () {\n  function InputSummary(internal) {\n    _classCallCheck(this, InputSummary);\n\n    this[_] = internal;\n  }\n\n  _createClass(InputSummary, [{\n    key: \"advance\",\n    value: function advance() {\n      throw new Error('advance() is not supported on an interleave summary');\n    }\n  }, {\n    key: \"current\",\n    get: function get() {\n      return {\n        value: this.value,\n        done: this.done\n      };\n    }\n  }, {\n    key: \"value\",\n    get: function get() {\n      return this[_].notDoneBuffer;\n    }\n  }, {\n    key: \"done\",\n    get: function get() {\n      return this[_].notDoneBuffer === undefined;\n    }\n  }, {\n    key: \"index\",\n    get: function get() {\n      return this[_].index;\n    }\n  }]);\n\n  return InputSummary;\n}();\n\nexports.InputSummary = InputSummary;\n\nvar Interleaver = /*#__PURE__*/function (_IterableIterator) {\n  _inherits(Interleaver, _IterableIterator);\n\n  var _super2 = _createSuper(Interleaver);\n\n  function Interleaver(sources, strategy, options) {\n    var _this2;\n\n    _classCallCheck(this, Interleaver);\n\n    _this2 = _super2.call(this);\n    _this2.sources = sources;\n    _this2.strategy = strategy;\n    _this2.options = options;\n    _this2.initialized = false;\n    _this2.inputSummary = new InputSummaryInternal(sources);\n    return _this2;\n  }\n\n  _createClass(Interleaver, [{\n    key: \"init\",\n    value: function init() {\n      this.initialized = true;\n      var strategy = this.strategy,\n          options = this.options,\n          inputSummary = this.inputSummary;\n      this.buffers = __toArray(__map(this.sources, function (source) {\n        return SummarizedPeekerator.from(source, inputSummary);\n      }));\n      this.iterator = strategy.apply(void 0, [options, new InputSummary(inputSummary)].concat(_toConsumableArray(this.buffers)));\n      inputSummary.init(this.buffers);\n    }\n  }, {\n    key: \"returnBuffers\",\n    value: function returnBuffers() {\n      parallelEach(this.buffers, function (buffer) {\n        return buffer[\"return\"]();\n      });\n    }\n  }, {\n    key: \"next\",\n    value: function next() {\n      if (!this.initialized) this.init();\n      var step = this.iterator.next();\n      if (step.done) this.returnBuffers();\n      return step;\n    }\n  }, {\n    key: \"return\",\n    value: function _return() {\n      callReturn(this.iterator);\n      this.returnBuffers();\n      return {\n        value: undefined,\n        done: true\n      };\n    }\n  }]);\n\n  return Interleaver;\n}(IterableIterator);\n\nfunction __interleave(sources, strategy) {\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  return new Interleaver(sources, strategy, options);\n}\n\nexports.__interleave = __interleave;\nvar interleave = /*#__PURE__*/iterableCurry(__interleave, {\n  variadic: true,\n  growRight: true,\n  minArgs: 1,\n  maxArgs: 2\n});\nexports.interleave = interleave;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _asyncGeneratorDelegate = require(\"@babel/runtime/helpers/asyncGeneratorDelegate\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry,\n    asyncCache = _require.asyncCache;\n\nfunction __asyncInterposeSeq(_x, _x2) {\n  return _asyncInterposeSeq.apply(this, arguments);\n}\n\nexports.__asyncInterposeSeq = __asyncInterposeSeq;\n\nfunction _asyncInterposeSeq() {\n  _asyncInterposeSeq = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, seq) {\n    var subseq_, first, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, sourceValue;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            _context.next = 2;\n            return _awaitAsyncGenerator(asyncCache(seq));\n\n          case 2:\n            subseq_ = _context.sent;\n            first = true;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 6;\n            _iterator = _asyncIterator(source);\n\n          case 8:\n            _context.next = 10;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 10:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 14;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 14:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 25;\n              break;\n            }\n\n            sourceValue = _value;\n\n            if (first) {\n              _context.next = 19;\n              break;\n            }\n\n            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(subseq_), _awaitAsyncGenerator), \"t0\", 19);\n\n          case 19:\n            _context.next = 21;\n            return sourceValue;\n\n          case 21:\n            first = false;\n\n          case 22:\n            _iteratorNormalCompletion = true;\n            _context.next = 8;\n            break;\n\n          case 25:\n            _context.next = 31;\n            break;\n\n          case 27:\n            _context.prev = 27;\n            _context.t1 = _context[\"catch\"](6);\n            _didIteratorError = true;\n            _iteratorError = _context.t1;\n\n          case 31:\n            _context.prev = 31;\n            _context.prev = 32;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 36;\n              break;\n            }\n\n            _context.next = 36;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 36:\n            _context.prev = 36;\n\n            if (!_didIteratorError) {\n              _context.next = 39;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 39:\n            return _context.finish(36);\n\n          case 40:\n            return _context.finish(31);\n\n          case 41:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[6, 27, 31, 41], [32,, 36, 40]]);\n  }));\n  return _asyncInterposeSeq.apply(this, arguments);\n}\n\nvar asyncInterposeSeq = /*#__PURE__*/asyncIterableCurry(__asyncInterposeSeq);\nexports.asyncInterposeSeq = asyncInterposeSeq;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__interposeSeq);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry,\n    cache = _require.cache;\n\nfunction __interposeSeq(source, seq) {\n  var subseq_, first, _iterator, _step, sourceValue;\n\n  return _regeneratorRuntime.wrap(function __interposeSeq$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          subseq_ = cache(seq);\n          first = true;\n          _iterator = _createForOfIteratorHelper(source);\n          _context.prev = 3;\n\n          _iterator.s();\n\n        case 5:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 14;\n            break;\n          }\n\n          sourceValue = _step.value;\n\n          if (first) {\n            _context.next = 9;\n            break;\n          }\n\n          return _context.delegateYield(subseq_, \"t0\", 9);\n\n        case 9:\n          _context.next = 11;\n          return sourceValue;\n\n        case 11:\n          first = false;\n\n        case 12:\n          _context.next = 5;\n          break;\n\n        case 14:\n          _context.next = 19;\n          break;\n\n        case 16:\n          _context.prev = 16;\n          _context.t1 = _context[\"catch\"](3);\n\n          _iterator.e(_context.t1);\n\n        case 19:\n          _context.prev = 19;\n\n          _iterator.f();\n\n          return _context.finish(19);\n\n        case 22:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[3, 16, 19, 22]]);\n}\n\nexports.__interposeSeq = __interposeSeq;\nvar interposeSeq = /*#__PURE__*/iterableCurry(__interposeSeq);\nexports.interposeSeq = interposeSeq;","var _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$interpose-seq/async-interpose-seq.js'),\n    __asyncInterposeSeq = _require2.__asyncInterposeSeq;\n\nfunction __asyncInterpose(source, value) {\n  return __asyncInterposeSeq(source, [value]);\n}\n\nexports.__asyncInterpose = __asyncInterpose;\nvar asyncInterpose = /*#__PURE__*/asyncIterableCurry(__asyncInterpose, {\n  validateArgs: function validateArgs(args) {}\n});\nexports.asyncInterpose = asyncInterpose;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$interpose-seq/interpose-seq.js'),\n    __interposeSeq = _require2.__interposeSeq;\n\nfunction __interpose(source, value) {\n  return __interposeSeq(source, [value]);\n}\n\nexports.__interpose = __interpose;\nvar interpose = /*#__PURE__*/iterableCurry(__interpose, {\n  validateArgs: function validateArgs(args) {\n    if (true && typeof args[0] === 'string') {\n      console.warn(\"For string inputs use interposeSeq instead of interpose\");\n    }\n  }\n});\nexports.interpose = interpose;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$first-or/async-first-or.js'),\n    __asyncFirstOr = _require2.__asyncFirstOr;\n\nvar none = Symbol('none');\n\nfunction __asyncIsEmpty(_x) {\n  return _asyncIsEmpty.apply(this, arguments);\n}\n\nfunction _asyncIsEmpty() {\n  _asyncIsEmpty = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable) {\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            _context.next = 2;\n            return __asyncFirstOr(iterable, none);\n\n          case 2:\n            _context.t0 = _context.sent;\n            _context.t1 = none;\n            return _context.abrupt(\"return\", _context.t0 === _context.t1);\n\n          case 5:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncIsEmpty.apply(this, arguments);\n}\n\nexports.__asyncIsEmpty = __asyncIsEmpty;\nvar asyncIsEmpty = /*#__PURE__*/asyncIterableCurry(__asyncIsEmpty, {\n  reduces: true\n});\nexports.asyncIsEmpty = asyncIsEmpty;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$first-or/first-or.js'),\n    __firstOr = _require2.__firstOr;\n\nvar none = Symbol('none');\n\nfunction __isEmpty(iterable) {\n  return __firstOr(iterable, none) === none;\n}\n\nexports.__isEmpty = __isEmpty;\nvar isEmpty = /*#__PURE__*/iterableCurry(__isEmpty, {\n  reduces: true\n});\nexports.isEmpty = isEmpty;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../../internal/compare.js'),\n    defaultCompareOrder = _require2.defaultCompareOrder;\n\nvar _require3 = require('../$peekerate/async-peekerate.js'),\n    __asyncPeekerate = _require3.__asyncPeekerate;\n\nfunction __asyncIsSorted(_x) {\n  return _asyncIsSorted.apply(this, arguments);\n}\n\nfunction _asyncIsSorted() {\n  _asyncIsSorted = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable) {\n    var compare,\n        peekr,\n        value,\n        _args = arguments;\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            compare = _args.length > 1 && _args[1] !== undefined ? _args[1] : defaultCompareOrder;\n            _context.next = 3;\n            return __asyncPeekerate(iterable);\n\n          case 3:\n            peekr = _context.sent;\n\n          case 4:\n            if (peekr.done) {\n              _context.next = 14;\n              break;\n            }\n\n            value = peekr.value;\n            _context.next = 8;\n            return peekr.advance();\n\n          case 8:\n            if (!(!peekr.done && compare(value, peekr.value) > 0)) {\n              _context.next = 12;\n              break;\n            }\n\n            _context.next = 11;\n            return peekr[\"return\"]();\n\n          case 11:\n            return _context.abrupt(\"return\", false);\n\n          case 12:\n            _context.next = 4;\n            break;\n\n          case 14:\n            return _context.abrupt(\"return\", true);\n\n          case 15:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncIsSorted.apply(this, arguments);\n}\n\nexports.__asyncIsSorted = __asyncIsSorted;\nvar asyncIsSorted = /*#__PURE__*/asyncIterableCurry(__asyncIsSorted, {\n  reduces: true,\n  minArgs: 0,\n  maxArgs: 1\n});\nexports.asyncIsSorted = asyncIsSorted;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../../internal/compare.js'),\n    defaultCompareOrder = _require2.defaultCompareOrder;\n\nvar _require3 = require('../$peekerate/peekerate.js'),\n    __peekerate = _require3.__peekerate;\n\nfunction __isSorted(iterable) {\n  var compare = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultCompareOrder;\n\n  var peekr = __peekerate(iterable);\n\n  while (!peekr.done) {\n    var value = peekr.value;\n    peekr.advance();\n\n    if (!peekr.done && compare(value, peekr.value) > 0) {\n      peekr[\"return\"]();\n      return false;\n    }\n  }\n\n  return true;\n}\n\nexports.__isSorted = __isSorted;\nvar isSorted = /*#__PURE__*/iterableCurry(__isSorted, {\n  reduces: true,\n  minArgs: 0,\n  maxArgs: 1\n});\nexports.isSorted = isSorted;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _asyncGeneratorDelegate = require(\"@babel/runtime/helpers/asyncGeneratorDelegate\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$to-array/async-to-array.js'),\n    __asyncToArray = _require2.__asyncToArray;\n\nfunction __asyncJoinWithSeq(_x, _x2) {\n  return _asyncJoinWithSeq.apply(this, arguments);\n}\n\nexports.__asyncJoinWithSeq = __asyncJoinWithSeq;\n\nfunction _asyncJoinWithSeq() {\n  _asyncJoinWithSeq = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, separatorSeq) {\n    var _separatorSeq, isFirst, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            _context.next = 2;\n            return _awaitAsyncGenerator(__asyncToArray(separatorSeq));\n\n          case 2:\n            _separatorSeq = _context.sent;\n            isFirst = true;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 6;\n            _iterator = _asyncIterator(source);\n\n          case 8:\n            _context.next = 10;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 10:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 14;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 14:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 24;\n              break;\n            }\n\n            value = _value;\n\n            if (isFirst) {\n              _context.next = 19;\n              break;\n            }\n\n            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(_separatorSeq), _awaitAsyncGenerator), \"t0\", 19);\n\n          case 19:\n            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(value), _awaitAsyncGenerator), \"t1\", 20);\n\n          case 20:\n            isFirst = false;\n\n          case 21:\n            _iteratorNormalCompletion = true;\n            _context.next = 8;\n            break;\n\n          case 24:\n            _context.next = 30;\n            break;\n\n          case 26:\n            _context.prev = 26;\n            _context.t2 = _context[\"catch\"](6);\n            _didIteratorError = true;\n            _iteratorError = _context.t2;\n\n          case 30:\n            _context.prev = 30;\n            _context.prev = 31;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 35;\n              break;\n            }\n\n            _context.next = 35;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 35:\n            _context.prev = 35;\n\n            if (!_didIteratorError) {\n              _context.next = 38;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 38:\n            return _context.finish(35);\n\n          case 39:\n            return _context.finish(30);\n\n          case 40:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[6, 26, 30, 40], [31,, 35, 39]]);\n  }));\n  return _asyncJoinWithSeq.apply(this, arguments);\n}\n\nvar asyncJoinWithSeq = /*#__PURE__*/asyncIterableCurry(__asyncJoinWithSeq);\nexports.asyncJoinWithSeq = asyncJoinWithSeq;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__joinWithSeq);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$to-array/to-array.js'),\n    __toArray = _require2.__toArray;\n\nfunction __joinWithSeq(source, separatorSeq) {\n  var _separatorSeq, isFirst, _iterator, _step, value;\n\n  return _regeneratorRuntime.wrap(function __joinWithSeq$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          _separatorSeq = __toArray(separatorSeq);\n          isFirst = true;\n          _iterator = _createForOfIteratorHelper(source);\n          _context.prev = 3;\n\n          _iterator.s();\n\n        case 5:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 13;\n            break;\n          }\n\n          value = _step.value;\n\n          if (isFirst) {\n            _context.next = 9;\n            break;\n          }\n\n          return _context.delegateYield(_separatorSeq, \"t0\", 9);\n\n        case 9:\n          return _context.delegateYield(value, \"t1\", 10);\n\n        case 10:\n          isFirst = false;\n\n        case 11:\n          _context.next = 5;\n          break;\n\n        case 13:\n          _context.next = 18;\n          break;\n\n        case 15:\n          _context.prev = 15;\n          _context.t2 = _context[\"catch\"](3);\n\n          _iterator.e(_context.t2);\n\n        case 18:\n          _context.prev = 18;\n\n          _iterator.f();\n\n          return _context.finish(18);\n\n        case 21:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[3, 15, 18, 21]]);\n}\n\nexports.__joinWithSeq = __joinWithSeq;\nvar joinWithSeq = /*#__PURE__*/iterableCurry(__joinWithSeq);\nexports.joinWithSeq = joinWithSeq;","var _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$join-with-seq/async-join-with-seq.js'),\n    __asyncJoinWithSeq = _require2.__asyncJoinWithSeq;\n\nfunction __asyncJoinWith(source, separator) {\n  return __asyncJoinWithSeq(source, [separator]);\n}\n\nexports.__asyncJoinWith = __asyncJoinWith;\nvar asyncJoinWith = /*#__PURE__*/asyncIterableCurry(__asyncJoinWith, {\n  validateArgs: function validateArgs(args) {}\n});\nexports.asyncJoinWith = asyncJoinWith;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$join-with-seq/join-with-seq.js'),\n    __joinWithSeq = _require2.__joinWithSeq;\n\nfunction __joinWith(source, separator) {\n  return __joinWithSeq(source, [separator]);\n}\n\nexports.__joinWith = __joinWith;\nvar joinWith = /*#__PURE__*/iterableCurry(__joinWith, {\n  validateArgs: function validateArgs(args) {\n    if (true && typeof args[0] === 'string') {\n      console.warn(\"For string inputs use joinWithSeq instead of joinWith\");\n    }\n  }\n});\nexports.joinWith = joinWith;","var _require = require('../../internal/async-iterable.js'),\n    asyncWrapWithIterableIterator = _require.asyncWrapWithIterableIterator,\n    asyncEnsureIterable = _require.asyncEnsureIterable;\n\nvar _require2 = require('../$join-with-seq/async-join-with-seq.js'),\n    __asyncJoinWithSeq = _require2.__asyncJoinWithSeq;\n\nvar emptySeq = [];\n\nfunction __asyncJoin(source) {\n  return __asyncJoinWithSeq(asyncEnsureIterable(source), emptySeq);\n}\n\nexports.__asyncJoin = __asyncJoin;\nvar asyncJoin = /*#__PURE__*/asyncWrapWithIterableIterator(__asyncJoin);\nexports.asyncJoin = asyncJoin;","var _require = require('../../internal/iterable.js'),\n    wrapWithIterableIterator = _require.wrapWithIterableIterator,\n    ensureIterable = _require.ensureIterable;\n\nvar _require2 = require('../$join-with-seq/join-with-seq.js'),\n    __joinWithSeq = _require2.__joinWithSeq;\n\nvar emptySeq = [];\n\nfunction __join(source) {\n  return __joinWithSeq(ensureIterable(source), emptySeq);\n}\n\nexports.__join = __join;\nvar join = /*#__PURE__*/wrapWithIterableIterator(__join);\nexports.join = join;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nfunction __asyncMap(_x, _x2) {\n  return _asyncMap.apply(this, arguments);\n}\n\nexports.__asyncMap = __asyncMap;\n\nfunction _asyncMap() {\n  _asyncMap = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, func) {\n    var c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            c = 0;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 3;\n            _iterator = _asyncIterator(source);\n\n          case 5:\n            _context.next = 7;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 7:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 11;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 11:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 19;\n              break;\n            }\n\n            value = _value;\n            _context.next = 16;\n            return func(value, c++);\n\n          case 16:\n            _iteratorNormalCompletion = true;\n            _context.next = 5;\n            break;\n\n          case 19:\n            _context.next = 25;\n            break;\n\n          case 21:\n            _context.prev = 21;\n            _context.t0 = _context[\"catch\"](3);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 25:\n            _context.prev = 25;\n            _context.prev = 26;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 30;\n              break;\n            }\n\n            _context.next = 30;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 30:\n            _context.prev = 30;\n\n            if (!_didIteratorError) {\n              _context.next = 33;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 33:\n            return _context.finish(30);\n\n          case 34:\n            return _context.finish(25);\n\n          case 35:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[3, 21, 25, 35], [26,, 30, 34]]);\n  }));\n  return _asyncMap.apply(this, arguments);\n}\n\nvar asyncMap = /*#__PURE__*/asyncIterableCurry(__asyncMap);\nexports.asyncMap = asyncMap;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__map);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nfunction __map(source, func) {\n  var c, _iterator, _step, value;\n\n  return _regeneratorRuntime.wrap(function __map$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          c = 0;\n          _iterator = _createForOfIteratorHelper(source);\n          _context.prev = 2;\n\n          _iterator.s();\n\n        case 4:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 10;\n            break;\n          }\n\n          value = _step.value;\n          _context.next = 8;\n          return func(value, c++);\n\n        case 8:\n          _context.next = 4;\n          break;\n\n        case 10:\n          _context.next = 15;\n          break;\n\n        case 12:\n          _context.prev = 12;\n          _context.t0 = _context[\"catch\"](2);\n\n          _iterator.e(_context.t0);\n\n        case 15:\n          _context.prev = 15;\n\n          _iterator.f();\n\n          return _context.finish(15);\n\n        case 18:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[2, 12, 15, 18]]);\n}\n\nexports.__map = __map;\nvar map = /*#__PURE__*/iterableCurry(__map);\nexports.map = map;","var _require = require('../../internal/async-iterable.js'),\n    asyncEnsureIterable = _require.asyncEnsureIterable;\n\nvar _require2 = require('../../internal/async-peekerator.js'),\n    AsyncPeekerator = _require2.AsyncPeekerator;\n\nfunction __asyncPeekerate(source) {\n  return AsyncPeekerator.from(source);\n}\n\nexports.__asyncPeekerate = __asyncPeekerate;\n\nfunction asyncWrapWithEnsureIterable(fn) {\n  return function (source) {\n    return fn(asyncEnsureIterable(source));\n  };\n}\n\nvar asyncPeekerate = asyncWrapWithEnsureIterable(__asyncPeekerate);\nexports.asyncPeekerate = asyncPeekerate;","var _require = require('../../internal/iterable.js'),\n    ensureIterable = _require.ensureIterable;\n\nvar _require2 = require('../../internal/peekerator.js'),\n    Peekerator = _require2.Peekerator;\n\nfunction __peekerate(source) {\n  return Peekerator.from(source);\n}\n\nexports.__peekerate = __peekerate;\n\nfunction wrapWithEnsureIterable(fn) {\n  return function (source) {\n    return fn(ensureIterable(source));\n  };\n}\n\nvar peekerate = wrapWithEnsureIterable(__peekerate);\nexports.peekerate = peekerate;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _asyncGeneratorDelegate = require(\"@babel/runtime/helpers/asyncGeneratorDelegate\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nfunction __asyncPrepend(_x, _x2) {\n  return _asyncPrepend.apply(this, arguments);\n}\n\nexports.__asyncPrepend = __asyncPrepend;\n\nfunction _asyncPrepend() {\n  _asyncPrepend = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, value) {\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            _context.next = 2;\n            return value;\n\n          case 2:\n            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(source), _awaitAsyncGenerator), \"t0\", 3);\n\n          case 3:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncPrepend.apply(this, arguments);\n}\n\nvar asyncPrepend = /*#__PURE__*/asyncIterableCurry(__asyncPrepend);\nexports.asyncPrepend = asyncPrepend;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__prepend);\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nfunction __prepend(source, value) {\n  return _regeneratorRuntime.wrap(function __prepend$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          _context.next = 2;\n          return value;\n\n        case 2:\n          return _context.delegateYield(source, \"t0\", 3);\n\n        case 3:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nexports.__prepend = __prepend;\nvar prepend = /*#__PURE__*/iterableCurry(__prepend);\nexports.prepend = prepend;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$peekerate/async-peekerate.js'),\n    __asyncPeekerate = _require2.__asyncPeekerate;\n\nfunction __asyncReduce(_x, _x2) {\n  return _asyncReduce.apply(this, arguments);\n}\n\nfunction _asyncReduce() {\n  _asyncReduce = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, reducer) {\n    var initial,\n        c,\n        result,\n        peekr,\n        _args = arguments;\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            initial = _args.length > 2 && _args[2] !== undefined ? _args[2] : undefined;\n            c = 0;\n            result = initial;\n            _context.next = 5;\n            return __asyncPeekerate(iterable);\n\n          case 5:\n            peekr = _context.sent;\n            _context.prev = 6;\n\n            if (!(initial === undefined)) {\n              _context.next = 14;\n              break;\n            }\n\n            if (!peekr.done) {\n              _context.next = 10;\n              break;\n            }\n\n            throw new Error('Cannot reduce: no initial value specified and iterable was empty');\n\n          case 10:\n            result = peekr.value;\n            _context.next = 13;\n            return peekr.advance();\n\n          case 13:\n            c = 1;\n\n          case 14:\n            if (peekr.done) {\n              _context.next = 22;\n              break;\n            }\n\n            _context.next = 17;\n            return reducer(result, peekr.value, c++);\n\n          case 17:\n            result = _context.sent;\n            _context.next = 20;\n            return peekr.advance();\n\n          case 20:\n            _context.next = 14;\n            break;\n\n          case 22:\n            return _context.abrupt(\"return\", result);\n\n          case 23:\n            _context.prev = 23;\n            peekr[\"return\"]();\n            return _context.finish(23);\n\n          case 26:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[6,, 23, 26]]);\n  }));\n  return _asyncReduce.apply(this, arguments);\n}\n\nexports.__asyncReduce = __asyncReduce;\nvar asyncReduce = /*#__PURE__*/asyncIterableCurry(__asyncReduce, {\n  reduces: true,\n  minArgs: 1,\n  maxArgs: 2\n});\nexports.asyncReduce = asyncReduce;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$peekerate/peekerate.js'),\n    __peekerate = _require2.__peekerate;\n\nfunction __reduce(iterable, reducer) {\n  var initial = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;\n  var c = 0;\n  var result = initial;\n\n  var peekr = __peekerate(iterable);\n\n  try {\n    if (initial === undefined) {\n      if (peekr.done) {\n        throw new Error('Cannot reduce: no initial value specified and iterable was empty');\n      }\n\n      result = peekr.value;\n      peekr.advance();\n      c = 1;\n    }\n\n    while (!peekr.done) {\n      result = reducer(result, peekr.value, c++);\n      peekr.advance();\n    }\n\n    return result;\n  } finally {\n    peekr[\"return\"]();\n  }\n}\n\nexports.__reduce = __reduce;\nvar reduce = /*#__PURE__*/iterableCurry(__reduce, {\n  reduces: true,\n  minArgs: 1,\n  maxArgs: 2\n});\nexports.reduce = reduce;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _asyncGeneratorDelegate = require(\"@babel/runtime/helpers/asyncGeneratorDelegate\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$to-array/async-to-array.js'),\n    __asyncToArray = _require2.__asyncToArray;\n\nfunction __asyncReverse(_x) {\n  return _asyncReverse.apply(this, arguments);\n}\n\nexports.__asyncReverse = __asyncReverse;\n\nfunction _asyncReverse() {\n  _asyncReverse = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source) {\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            _context.t0 = _asyncGeneratorDelegate;\n            _context.t1 = _asyncIterator;\n            _context.next = 4;\n            return _awaitAsyncGenerator(__asyncToArray(source));\n\n          case 4:\n            _context.t2 = _context.sent.reverse();\n            _context.t3 = (0, _context.t1)(_context.t2);\n            _context.t4 = _awaitAsyncGenerator;\n            return _context.delegateYield((0, _context.t0)(_context.t3, _context.t4), \"t5\", 8);\n\n          case 8:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncReverse.apply(this, arguments);\n}\n\nvar asyncReverse = /*#__PURE__*/asyncIterableCurry(__asyncReverse);\nexports.asyncReverse = asyncReverse;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__reverse);\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$to-array/to-array.js'),\n    __toArray = _require2.__toArray;\n\nfunction __reverse(source) {\n  return _regeneratorRuntime.wrap(function __reverse$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          return _context.delegateYield(__toArray(source).reverse(), \"t0\", 1);\n\n        case 1:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nexports.__reverse = __reverse;\nvar reverse = /*#__PURE__*/iterableCurry(__reverse);\nexports.reverse = reverse;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$interleave/async-interleave.js'),\n    __asyncInterleave = _require2.__asyncInterleave;\n\nvar _require3 = require('./internal/validate-args.js'),\n    makeValidateArgs = _require3.makeValidateArgs;\n\nfunction asyncByPosition(_x, _x2) {\n  return _asyncByPosition.apply(this, arguments);\n}\n\nfunction _asyncByPosition() {\n  _asyncByPosition = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref, all) {\n    var start,\n        step,\n        _len,\n        peekrs,\n        _key,\n        i,\n        peekr,\n        _args = arguments;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            start = _ref.start, step = _ref.step;\n\n            for (_len = _args.length, peekrs = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n              peekrs[_key - 2] = _args[_key];\n            }\n\n            start = start % peekrs.length;\n            i = start;\n\n          case 4:\n            if (all.done) {\n              _context.next = 14;\n              break;\n            }\n\n            peekr = peekrs[i];\n\n            if (peekr.done) {\n              _context.next = 11;\n              break;\n            }\n\n            _context.next = 9;\n            return peekr.value;\n\n          case 9:\n            _context.next = 11;\n            return _awaitAsyncGenerator(peekr.advance());\n\n          case 11:\n            i = (i + step) % peekrs.length;\n            _context.next = 4;\n            break;\n\n          case 14:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncByPosition.apply(this, arguments);\n}\n\nfunction __asyncRoundRobin(sources) {\n  var step = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;\n  var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n  return __asyncInterleave(sources, asyncByPosition, {\n    start: start,\n    step: step\n  });\n}\n\nexports.__asyncRoundRobin = __asyncRoundRobin;\nvar asyncRoundRobin = /*#__PURE__*/asyncIterableCurry(__asyncRoundRobin, {\n  variadic: true,\n  minArgs: 0,\n  maxArgs: 2,\n  validateArgs: /*#__PURE__*/makeValidateArgs('asyncRoundRobin')\n});\nexports.asyncRoundRobin = asyncRoundRobin;","var _require = require('../../../internal/number.js'),\n    isInteger = _require.isInteger;\n\nvar _require2 = require('../../is-object/is-object.js'),\n    isObject = _require2.isObject;\n\nvar _require3 = require('../../not-undefined/not-undefined.js'),\n    notUndefined = _require3.notUndefined;\n\nvar makeValidateArgs = function makeValidateArgs(methodName) {\n  return function validateArgs(args) {\n    if (isObject(args[1])) {\n      var _args$ = args[1],\n          start = _args$.start,\n          step = _args$.step;\n      args[1] = start;\n      args[2] = step;\n    }\n\n    if (notUndefined(args[2])) {\n      args[2] = Number(args[2]);\n\n      if (!isInteger(args[2], true)) {\n        throw new Error(\"step argument to \".concat(methodName, \" must be a non-zero integer\"));\n      }\n    }\n  };\n};\n\nexports.makeValidateArgs = makeValidateArgs;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(byPosition);\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$interleave/interleave.js'),\n    __interleave = _require2.__interleave;\n\nvar _require3 = require('./internal/validate-args.js'),\n    makeValidateArgs = _require3.makeValidateArgs;\n\nfunction byPosition(_ref, all) {\n  var start,\n      step,\n      _len,\n      peekrs,\n      _key,\n      i,\n      peekr,\n      _args = arguments;\n\n  return _regeneratorRuntime.wrap(function byPosition$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          start = _ref.start, step = _ref.step;\n\n          for (_len = _args.length, peekrs = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n            peekrs[_key - 2] = _args[_key];\n          }\n\n          start = start % peekrs.length;\n          i = start;\n\n        case 4:\n          if (all.done) {\n            _context.next = 13;\n            break;\n          }\n\n          peekr = peekrs[i];\n\n          if (peekr.done) {\n            _context.next = 10;\n            break;\n          }\n\n          _context.next = 9;\n          return peekr.value;\n\n        case 9:\n          peekr.advance();\n\n        case 10:\n          i = (i + step) % peekrs.length;\n          _context.next = 4;\n          break;\n\n        case 13:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nfunction __roundRobin(sources) {\n  var step = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;\n  var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n  return __interleave(sources, byPosition, {\n    start: start,\n    step: step\n  });\n}\n\nexports.__roundRobin = __roundRobin;\nvar roundRobin = /*#__PURE__*/iterableCurry(__roundRobin, {\n  variadic: true,\n  minArgs: 0,\n  maxArgs: 2,\n  validateArgs: /*#__PURE__*/makeValidateArgs('roundRobin')\n});\nexports.roundRobin = roundRobin;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncEnsureIterable = _require.asyncEnsureIterable;\n\nfunction __asyncSize(_x) {\n  return _asyncSize.apply(this, arguments);\n}\n\nfunction _asyncSize() {\n  _asyncSize = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable) {\n    var iter, size, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, _;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            iter = asyncEnsureIterable(iterable);\n            size = 0;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 4;\n            _iterator = _asyncIterator(iter);\n\n          case 6:\n            _context.next = 8;\n            return _iterator.next();\n\n          case 8:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 12;\n            return _step.value;\n\n          case 12:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 19;\n              break;\n            }\n\n            _ = _value;\n            size++;\n\n          case 16:\n            _iteratorNormalCompletion = true;\n            _context.next = 6;\n            break;\n\n          case 19:\n            _context.next = 25;\n            break;\n\n          case 21:\n            _context.prev = 21;\n            _context.t0 = _context[\"catch\"](4);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 25:\n            _context.prev = 25;\n            _context.prev = 26;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 30;\n              break;\n            }\n\n            _context.next = 30;\n            return _iterator[\"return\"]();\n\n          case 30:\n            _context.prev = 30;\n\n            if (!_didIteratorError) {\n              _context.next = 33;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 33:\n            return _context.finish(30);\n\n          case 34:\n            return _context.finish(25);\n\n          case 35:\n            return _context.abrupt(\"return\", size);\n\n          case 36:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[4, 21, 25, 35], [26,, 30, 34]]);\n  }));\n  return _asyncSize.apply(this, arguments);\n}\n\nexports.__asyncSize = __asyncSize;\nvar asyncSize = __asyncSize;\nexports.asyncSize = asyncSize;","function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    ensureIterable = _require.ensureIterable;\n\nfunction __size(iterable) {\n  var iter = ensureIterable(iterable);\n  var size = 0;\n\n  var _iterator = _createForOfIteratorHelper(iter),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var _ = _step.value;\n      size++;\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  return size;\n}\n\nexports.__size = __size;\nvar size = __size;\nexports.size = size;","var _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncGeneratorDelegate = require(\"@babel/runtime/helpers/asyncGeneratorDelegate\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/circular-buffer.js'),\n    CircularBuffer = _require.CircularBuffer;\n\nvar _require2 = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require2.asyncIterableCurry;\n\nvar _require3 = require('./internal/validate-args.js'),\n    makeValidateArgs = _require3.makeValidateArgs;\n\nfunction __asyncSliceFromStart(_x) {\n  return _asyncSliceFromStart.apply(this, arguments);\n}\n\nexports.__asyncSliceFromStart = __asyncSliceFromStart;\n\nfunction _asyncSliceFromStart() {\n  _asyncSliceFromStart = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source) {\n    var start,\n        end,\n        step,\n        currentPos,\n        nextValidPos,\n        bufferSize,\n        buffer,\n        counter,\n        _iteratorNormalCompletion,\n        _didIteratorError,\n        _iteratorError,\n        _iterator,\n        _step,\n        _value,\n        value,\n        _args = arguments;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            start = _args.length > 1 && _args[1] !== undefined ? _args[1] : 0;\n            end = _args.length > 2 && _args[2] !== undefined ? _args[2] : Infinity;\n            step = _args.length > 3 && _args[3] !== undefined ? _args[3] : 1;\n            currentPos = 0;\n            nextValidPos = start;\n            bufferSize = Math.abs(end);\n            counter = 0;\n\n            if (end < 0) {\n              buffer = new CircularBuffer(bufferSize);\n            }\n\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 10;\n            _iterator = _asyncIterator(source);\n\n          case 12:\n            _context.next = 14;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 14:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 18;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 18:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 36;\n              break;\n            }\n\n            value = _value;\n\n            if (!buffer) {\n              _context.next = 26;\n              break;\n            }\n\n            value = buffer.push(value);\n            counter++;\n\n            if (!(counter <= bufferSize)) {\n              _context.next = 26;\n              break;\n            }\n\n            return _context.abrupt(\"continue\", 33);\n\n          case 26:\n            if (!(currentPos >= end && end >= 0)) {\n              _context.next = 28;\n              break;\n            }\n\n            return _context.abrupt(\"break\", 36);\n\n          case 28:\n            if (!(nextValidPos === currentPos)) {\n              _context.next = 32;\n              break;\n            }\n\n            _context.next = 31;\n            return value;\n\n          case 31:\n            nextValidPos += step;\n\n          case 32:\n            currentPos++;\n\n          case 33:\n            _iteratorNormalCompletion = true;\n            _context.next = 12;\n            break;\n\n          case 36:\n            _context.next = 42;\n            break;\n\n          case 38:\n            _context.prev = 38;\n            _context.t0 = _context[\"catch\"](10);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 42:\n            _context.prev = 42;\n            _context.prev = 43;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 47;\n              break;\n            }\n\n            _context.next = 47;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 47:\n            _context.prev = 47;\n\n            if (!_didIteratorError) {\n              _context.next = 50;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 50:\n            return _context.finish(47);\n\n          case 51:\n            return _context.finish(42);\n\n          case 52:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[10, 38, 42, 52], [43,, 47, 51]]);\n  }));\n  return _asyncSliceFromStart.apply(this, arguments);\n}\n\nfunction asyncBufferedSlice(_x3, _x4, _x5, _x6) {\n  return _asyncBufferedSlice.apply(this, arguments);\n}\n\nfunction _asyncBufferedSlice() {\n  _asyncBufferedSlice = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(source, start, end, step) {\n    var bufferSize, buffer, counter, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, _value2, value, newEnd;\n\n    return _regeneratorRuntime.wrap(function _callee3$(_context3) {\n      while (1) {\n        switch (_context3.prev = _context3.next) {\n          case 0:\n            bufferSize = Math.abs(start);\n            buffer = new CircularBuffer(bufferSize);\n            counter = 0;\n            _iteratorNormalCompletion2 = true;\n            _didIteratorError2 = false;\n            _context3.prev = 5;\n            _iterator2 = _asyncIterator(source);\n\n          case 7:\n            _context3.next = 9;\n            return _iterator2.next();\n\n          case 9:\n            _step2 = _context3.sent;\n            _iteratorNormalCompletion2 = _step2.done;\n            _context3.next = 13;\n            return _step2.value;\n\n          case 13:\n            _value2 = _context3.sent;\n\n            if (_iteratorNormalCompletion2) {\n              _context3.next = 21;\n              break;\n            }\n\n            value = _value2;\n            buffer.push(value);\n            counter++;\n\n          case 18:\n            _iteratorNormalCompletion2 = true;\n            _context3.next = 7;\n            break;\n\n          case 21:\n            _context3.next = 27;\n            break;\n\n          case 23:\n            _context3.prev = 23;\n            _context3.t0 = _context3[\"catch\"](5);\n            _didIteratorError2 = true;\n            _iteratorError2 = _context3.t0;\n\n          case 27:\n            _context3.prev = 27;\n            _context3.prev = 28;\n\n            if (!(!_iteratorNormalCompletion2 && _iterator2[\"return\"] != null)) {\n              _context3.next = 32;\n              break;\n            }\n\n            _context3.next = 32;\n            return _iterator2[\"return\"]();\n\n          case 32:\n            _context3.prev = 32;\n\n            if (!_didIteratorError2) {\n              _context3.next = 35;\n              break;\n            }\n\n            throw _iteratorError2;\n\n          case 35:\n            return _context3.finish(32);\n\n          case 36:\n            return _context3.finish(27);\n\n          case 37:\n            if (!(isFinite(end) && end > 0)) {\n              _context3.next = 43;\n              break;\n            }\n\n            newEnd = end - (counter - buffer.size);\n\n            if (!(newEnd < 0)) {\n              _context3.next = 41;\n              break;\n            }\n\n            return _context3.abrupt(\"return\", []);\n\n          case 41:\n            _context3.next = 44;\n            break;\n\n          case 43:\n            newEnd = end;\n\n          case 44:\n            return _context3.abrupt(\"return\", __asyncSliceFromStart(buffer, 0, newEnd, step));\n\n          case 45:\n          case \"end\":\n            return _context3.stop();\n        }\n      }\n    }, _callee3, null, [[5, 23, 27, 37], [28,, 32, 36]]);\n  }));\n  return _asyncBufferedSlice.apply(this, arguments);\n}\n\nfunction __asyncSlice(_x2) {\n  return _asyncSlice.apply(this, arguments);\n}\n\nexports.__asyncSlice = __asyncSlice;\n\nfunction _asyncSlice() {\n  _asyncSlice = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(source) {\n    var start,\n        end,\n        step,\n        _args2 = arguments;\n    return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n      while (1) {\n        switch (_context2.prev = _context2.next) {\n          case 0:\n            start = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : 0;\n            end = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : Infinity;\n            step = _args2.length > 3 && _args2[3] !== undefined ? _args2[3] : 1;\n\n            if (!(start >= 0)) {\n              _context2.next = 7;\n              break;\n            }\n\n            return _context2.delegateYield(_asyncGeneratorDelegate(_asyncIterator(__asyncSliceFromStart(source, start, end, step)), _awaitAsyncGenerator), \"t0\", 5);\n\n          case 5:\n            _context2.next = 15;\n            break;\n\n          case 7:\n            _context2.t1 = _asyncGeneratorDelegate;\n            _context2.t2 = _asyncIterator;\n            _context2.next = 11;\n            return _awaitAsyncGenerator(asyncBufferedSlice(source, start, end, step));\n\n          case 11:\n            _context2.t3 = _context2.sent;\n            _context2.t4 = (0, _context2.t2)(_context2.t3);\n            _context2.t5 = _awaitAsyncGenerator;\n            return _context2.delegateYield((0, _context2.t1)(_context2.t4, _context2.t5), \"t6\", 15);\n\n          case 15:\n          case \"end\":\n            return _context2.stop();\n        }\n      }\n    }, _callee2);\n  }));\n  return _asyncSlice.apply(this, arguments);\n}\n\nvar asyncSlice = /*#__PURE__*/asyncIterableCurry(__asyncSlice, {\n  validateArgs: /*#__PURE__*/makeValidateArgs('asyncSlice'),\n  growRight: true,\n  minArgs: 0,\n  maxArgs: 3\n});\nexports.asyncSlice = asyncSlice;","var _slicedToArray = require(\"@babel/runtime/helpers/slicedToArray\");\n\nvar _require = require('../../../internal/number.js'),\n    isInteger = _require.isInteger,\n    isPositiveInteger = _require.isPositiveInteger,\n    isIntegerOrInfinite = _require.isIntegerOrInfinite;\n\nvar _require2 = require('../../is-object/is-object.js'),\n    isObject = _require2.isObject;\n\nvar makeValidateArgs = function makeValidateArgs(methodName) {\n  return function validateArgs(args) {\n    var _args = _slicedToArray(args, 4),\n        _args$ = _args[1],\n        optsOrStart = _args$ === void 0 ? 0 : _args$,\n        _args$2 = _args[2],\n        end = _args$2 === void 0 ? Infinity : _args$2,\n        _args$3 = _args[3],\n        step = _args$3 === void 0 ? 1 : _args$3;\n\n    var start = typeof optsOrStart === 'number' ? optsOrStart : undefined;\n\n    if (isObject(optsOrStart)) {\n      var _optsOrStart$start = optsOrStart.start;\n      start = _optsOrStart$start === void 0 ? 0 : _optsOrStart$start;\n      var _optsOrStart$end = optsOrStart.end;\n      end = _optsOrStart$end === void 0 ? Infinity : _optsOrStart$end;\n      var _optsOrStart$step = optsOrStart.step;\n      step = _optsOrStart$step === void 0 ? 1 : _optsOrStart$step;\n    }\n\n    if (!isInteger(start)) {\n      throw new TypeError(\"start argument to \".concat(methodName, \" must be a number\"));\n    }\n\n    if (!isIntegerOrInfinite(end)) {\n      throw new TypeError(\"end argument to \".concat(methodName, \" must be an integer or infinte\"));\n    }\n\n    if (!isPositiveInteger(step)) {\n      throw new TypeError(\"step argument to \".concat(methodName, \" must be a integer > 0\"));\n    }\n\n    args[1] = start;\n    args[2] = end;\n    args[3] = step;\n  };\n};\n\nexports.makeValidateArgs = makeValidateArgs;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__sliceFromStart),\n    _marked2 = /*#__PURE__*/_regeneratorRuntime.mark(__slice);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/circular-buffer.js'),\n    CircularBuffer = _require.CircularBuffer;\n\nvar _require2 = require('../../internal/iterable.js'),\n    iterableCurry = _require2.iterableCurry;\n\nvar _require3 = require('./internal/validate-args.js'),\n    makeValidateArgs = _require3.makeValidateArgs;\n\nfunction __sliceFromStart(source) {\n  var start,\n      end,\n      step,\n      currentPos,\n      nextValidPos,\n      bufferSize,\n      buffer,\n      counter,\n      _iterator2,\n      _step2,\n      value,\n      _args = arguments;\n\n  return _regeneratorRuntime.wrap(function __sliceFromStart$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          start = _args.length > 1 && _args[1] !== undefined ? _args[1] : 0;\n          end = _args.length > 2 && _args[2] !== undefined ? _args[2] : Infinity;\n          step = _args.length > 3 && _args[3] !== undefined ? _args[3] : 1;\n          currentPos = 0;\n          nextValidPos = start;\n          bufferSize = Math.abs(end);\n          counter = 0;\n\n          if (end < 0) {\n            buffer = new CircularBuffer(bufferSize);\n          }\n\n          _iterator2 = _createForOfIteratorHelper(source);\n          _context.prev = 9;\n\n          _iterator2.s();\n\n        case 11:\n          if ((_step2 = _iterator2.n()).done) {\n            _context.next = 27;\n            break;\n          }\n\n          value = _step2.value;\n\n          if (!buffer) {\n            _context.next = 18;\n            break;\n          }\n\n          value = buffer.push(value);\n          counter++;\n\n          if (!(counter <= bufferSize)) {\n            _context.next = 18;\n            break;\n          }\n\n          return _context.abrupt(\"continue\", 25);\n\n        case 18:\n          if (!(currentPos >= end && end >= 0)) {\n            _context.next = 20;\n            break;\n          }\n\n          return _context.abrupt(\"break\", 27);\n\n        case 20:\n          if (!(nextValidPos === currentPos)) {\n            _context.next = 24;\n            break;\n          }\n\n          _context.next = 23;\n          return value;\n\n        case 23:\n          nextValidPos += step;\n\n        case 24:\n          currentPos++;\n\n        case 25:\n          _context.next = 11;\n          break;\n\n        case 27:\n          _context.next = 32;\n          break;\n\n        case 29:\n          _context.prev = 29;\n          _context.t0 = _context[\"catch\"](9);\n\n          _iterator2.e(_context.t0);\n\n        case 32:\n          _context.prev = 32;\n\n          _iterator2.f();\n\n          return _context.finish(32);\n\n        case 35:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[9, 29, 32, 35]]);\n}\n\nexports.__sliceFromStart = __sliceFromStart;\n\nfunction bufferedSlice(source, start, end, step) {\n  var bufferSize = Math.abs(start);\n  var buffer = new CircularBuffer(bufferSize);\n  var counter = 0;\n\n  var _iterator = _createForOfIteratorHelper(source),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var value = _step.value;\n      buffer.push(value);\n      counter++;\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  var newEnd;\n\n  if (isFinite(end) && end > 0) {\n    newEnd = end - (counter - buffer.size);\n    if (newEnd < 0) return [];\n  } else {\n    newEnd = end;\n  }\n\n  return __sliceFromStart(buffer, 0, newEnd, step);\n}\n\nfunction __slice(source) {\n  var start,\n      end,\n      step,\n      _args2 = arguments;\n  return _regeneratorRuntime.wrap(function __slice$(_context2) {\n    while (1) {\n      switch (_context2.prev = _context2.next) {\n        case 0:\n          start = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : 0;\n          end = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : Infinity;\n          step = _args2.length > 3 && _args2[3] !== undefined ? _args2[3] : 1;\n\n          if (!(start >= 0)) {\n            _context2.next = 7;\n            break;\n          }\n\n          return _context2.delegateYield(__sliceFromStart(source, start, end, step), \"t0\", 5);\n\n        case 5:\n          _context2.next = 8;\n          break;\n\n        case 7:\n          return _context2.delegateYield(bufferedSlice(source, start, end, step), \"t1\", 8);\n\n        case 8:\n        case \"end\":\n          return _context2.stop();\n      }\n    }\n  }, _marked2);\n}\n\nexports.__slice = __slice;\nvar slice = /*#__PURE__*/iterableCurry(__slice, {\n  validateArgs: /*#__PURE__*/makeValidateArgs('slice'),\n  growRight: true,\n  minArgs: 0,\n  maxArgs: 3\n});\nexports.slice = slice;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nfunction __asyncSome(_x, _x2) {\n  return _asyncSome.apply(this, arguments);\n}\n\nfunction _asyncSome() {\n  _asyncSome = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, func) {\n    var c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            c = 0;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 3;\n            _iterator = _asyncIterator(iterable);\n\n          case 5:\n            _context.next = 7;\n            return _iterator.next();\n\n          case 7:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 11;\n            return _step.value;\n\n          case 11:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 21;\n              break;\n            }\n\n            value = _value;\n            _context.next = 16;\n            return func(value, c++);\n\n          case 16:\n            if (!_context.sent) {\n              _context.next = 18;\n              break;\n            }\n\n            return _context.abrupt(\"return\", true);\n\n          case 18:\n            _iteratorNormalCompletion = true;\n            _context.next = 5;\n            break;\n\n          case 21:\n            _context.next = 27;\n            break;\n\n          case 23:\n            _context.prev = 23;\n            _context.t0 = _context[\"catch\"](3);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 27:\n            _context.prev = 27;\n            _context.prev = 28;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 32;\n              break;\n            }\n\n            _context.next = 32;\n            return _iterator[\"return\"]();\n\n          case 32:\n            _context.prev = 32;\n\n            if (!_didIteratorError) {\n              _context.next = 35;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 35:\n            return _context.finish(32);\n\n          case 36:\n            return _context.finish(27);\n\n          case 37:\n            return _context.abrupt(\"return\", false);\n\n          case 38:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[3, 23, 27, 37], [28,, 32, 36]]);\n  }));\n  return _asyncSome.apply(this, arguments);\n}\n\nexports.__asyncSome = __asyncSome;\nvar asyncSome = /*#__PURE__*/asyncIterableCurry(__asyncSome, {\n  reduces: true\n});\nexports.asyncSome = asyncSome;","function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nfunction __some(iterable, func) {\n  var c = 0;\n\n  var _iterator = _createForOfIteratorHelper(iterable),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var value = _step.value;\n\n      if (func(value, c++)) {\n        return true;\n      }\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  return false;\n}\n\nexports.__some = __some;\nvar some = /*#__PURE__*/iterableCurry(__some, {\n  reduces: true\n});\nexports.some = some;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$spliterate-grouped/async-spliterate-grouped.js'),\n    __asyncSpliterateGrouped = _require2.__asyncSpliterateGrouped;\n\nvar _require3 = require('../$peekerate/async-peekerate.js'),\n    __asyncPeekerate = _require3.__asyncPeekerate;\n\nvar initialKey = Symbol('initial group key');\n\nfunction asyncGroupingSpliterator(_x, _x2, _x3) {\n  return _asyncGroupingSpliterator.apply(this, arguments);\n}\n\nfunction _asyncGroupingSpliterator() {\n  _asyncGroupingSpliterator = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(split, _ref, source) {\n    var getKey, peekr, key, idx, lastKey;\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            getKey = _ref.getKey;\n            _context.next = 3;\n            return _awaitAsyncGenerator(__asyncPeekerate(source));\n\n          case 3:\n            peekr = _context.sent;\n            key = initialKey;\n            idx = 0;\n\n          case 6:\n            if (peekr.done) {\n              _context.next = 22;\n              break;\n            }\n\n            lastKey = key;\n            _context.next = 10;\n            return _awaitAsyncGenerator(getKey(peekr.value, idx++));\n\n          case 10:\n            key = _context.sent;\n\n            if (!(lastKey !== key)) {\n              _context.next = 16;\n              break;\n            }\n\n            _context.next = 14;\n            return split;\n\n          case 14:\n            _context.next = 16;\n            return key;\n\n          case 16:\n            _context.next = 18;\n            return peekr.value;\n\n          case 18:\n            _context.next = 20;\n            return _awaitAsyncGenerator(peekr.advance());\n\n          case 20:\n            _context.next = 6;\n            break;\n\n          case 22:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncGroupingSpliterator.apply(this, arguments);\n}\n\nfunction __asyncSplitGroups(source) {\n  var getKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (value) {\n    return value;\n  };\n  return __asyncSpliterateGrouped(source, asyncGroupingSpliterator, {\n    getKey: getKey\n  });\n}\n\nexports.__asyncSplitGroups = __asyncSplitGroups;\nvar asyncSplitGroups = /*#__PURE__*/asyncIterableCurry(__asyncSplitGroups, {\n  minArgs: 0,\n  maxArgs: 1\n});\nexports.asyncSplitGroups = asyncSplitGroups;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(groupingSpliterator);\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$spliterate-grouped/spliterate-grouped.js'),\n    __spliterateGrouped = _require2.__spliterateGrouped;\n\nvar _require3 = require('../$peekerate/peekerate.js'),\n    __peekerate = _require3.__peekerate;\n\nvar initialKey = Symbol('initial group key');\n\nfunction groupingSpliterator(split, _ref, source) {\n  var getKey, peekr, key, idx, lastKey;\n  return _regeneratorRuntime.wrap(function groupingSpliterator$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          getKey = _ref.getKey;\n          peekr = __peekerate(source);\n          key = initialKey;\n          idx = 0;\n\n        case 4:\n          if (peekr.done) {\n            _context.next = 17;\n            break;\n          }\n\n          lastKey = key;\n          key = getKey(peekr.value, idx++);\n\n          if (!(lastKey !== key)) {\n            _context.next = 12;\n            break;\n          }\n\n          _context.next = 10;\n          return split;\n\n        case 10:\n          _context.next = 12;\n          return key;\n\n        case 12:\n          _context.next = 14;\n          return peekr.value;\n\n        case 14:\n          peekr.advance();\n          _context.next = 4;\n          break;\n\n        case 17:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nfunction __splitGroups(source) {\n  var getKey = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (value) {\n    return value;\n  };\n  return __spliterateGrouped(source, groupingSpliterator, {\n    getKey: getKey\n  });\n}\n\nexports.__splitGroups = __splitGroups;\nvar splitGroups = /*#__PURE__*/iterableCurry(__splitGroups, {\n  minArgs: 0,\n  maxArgs: 1\n});\nexports.splitGroups = splitGroups;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _asyncGeneratorDelegate = require(\"@babel/runtime/helpers/asyncGeneratorDelegate\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../../internal/async-any-seq.js'),\n    asyncSeqsToArray = _require2.asyncSeqsToArray;\n\nvar _require3 = require('../$starts-with-seq/starts-with-seq.js'),\n    __startsWithSeq = _require3.__startsWithSeq;\n\nvar _require4 = require('../$window-ahead/async-window-ahead.js'),\n    __asyncWindowAhead = _require4.__asyncWindowAhead;\n\nvar _require5 = require('../$spliterate/async-spliterate.js'),\n    __asyncSpliterate = _require5.__asyncSpliterate;\n\nfunction getMatchingLength(buffer, separatorSeqs, same) {\n  var _iterator2 = _createForOfIteratorHelper(separatorSeqs),\n      _step2;\n\n  try {\n    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n      var subsequence = _step2.value;\n\n      if (__startsWithSeq(buffer, subsequence, same)) {\n        return subsequence.length;\n      }\n    }\n  } catch (err) {\n    _iterator2.e(err);\n  } finally {\n    _iterator2.f();\n  }\n\n  return 0;\n}\n\nfunction asyncAnySeqspliterator(_x, _x2, _x3) {\n  return _asyncAnySeqspliterator.apply(this, arguments);\n}\n\nfunction _asyncAnySeqspliterator() {\n  _asyncAnySeqspliterator = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(split, _ref, source) {\n    var separatorSeqs, same, maxMatchLength, skip, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, buffer, matchingLength;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            separatorSeqs = _ref.separatorSeqs, same = _ref.same;\n            maxMatchLength = separatorSeqs.reduce(function (max, _ref2) {\n              var length = _ref2.length;\n              return Math.max(max, length);\n            }, 1);\n            skip = 0;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 5;\n            _iterator = _asyncIterator(__asyncWindowAhead(source, maxMatchLength, {\n              useFiller: false\n            }));\n\n          case 7:\n            _context.next = 9;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 9:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 13;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 13:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 31;\n              break;\n            }\n\n            buffer = _value;\n\n            if (!(skip > 0)) {\n              _context.next = 19;\n              break;\n            }\n\n            skip--;\n            return _context.abrupt(\"continue\", 28);\n\n          case 19:\n            matchingLength = getMatchingLength(buffer, separatorSeqs, same);\n\n            if (!(matchingLength > 0)) {\n              _context.next = 26;\n              break;\n            }\n\n            _context.next = 23;\n            return split;\n\n          case 23:\n            skip = matchingLength - 1;\n            _context.next = 28;\n            break;\n\n          case 26:\n            _context.next = 28;\n            return buffer.get(0);\n\n          case 28:\n            _iteratorNormalCompletion = true;\n            _context.next = 7;\n            break;\n\n          case 31:\n            _context.next = 37;\n            break;\n\n          case 33:\n            _context.prev = 33;\n            _context.t0 = _context[\"catch\"](5);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 37:\n            _context.prev = 37;\n            _context.prev = 38;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 42;\n              break;\n            }\n\n            _context.next = 42;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 42:\n            _context.prev = 42;\n\n            if (!_didIteratorError) {\n              _context.next = 45;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 45:\n            return _context.finish(42);\n\n          case 46:\n            return _context.finish(37);\n\n          case 47:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[5, 33, 37, 47], [38,, 42, 46]]);\n  }));\n  return _asyncAnySeqspliterator.apply(this, arguments);\n}\n\nfunction __asyncSplitOnAnySeq(_x4, _x5) {\n  return _asyncSplitOnAnySeq.apply(this, arguments);\n}\n\nexports.__asyncSplitOnAnySeq = __asyncSplitOnAnySeq;\n\nfunction _asyncSplitOnAnySeq() {\n  _asyncSplitOnAnySeq = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(source, separatorSeqs) {\n    var same,\n        separatorSeqsArr,\n        _args2 = arguments;\n    return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n      while (1) {\n        switch (_context2.prev = _context2.next) {\n          case 0:\n            same = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : Object.is;\n            _context2.next = 3;\n            return _awaitAsyncGenerator(asyncSeqsToArray(separatorSeqs));\n\n          case 3:\n            separatorSeqsArr = _context2.sent.filter(function (s) {\n              return s.length > 0;\n            });\n            return _context2.delegateYield(_asyncGeneratorDelegate(_asyncIterator(__asyncSpliterate(source, asyncAnySeqspliterator, {\n              separatorSeqs: separatorSeqsArr.sort(function (a, b) {\n                return b.length - a.length;\n              }),\n              same: same\n            })), _awaitAsyncGenerator), \"t0\", 5);\n\n          case 5:\n          case \"end\":\n            return _context2.stop();\n        }\n      }\n    }, _callee2);\n  }));\n  return _asyncSplitOnAnySeq.apply(this, arguments);\n}\n\nvar asyncSplitOnAnySeq = /*#__PURE__*/asyncIterableCurry(__asyncSplitOnAnySeq, {\n  minArgs: 1,\n  maxArgs: 2\n});\nexports.asyncSplitOnAnySeq = asyncSplitOnAnySeq;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(anySeqspliterator),\n    _marked2 = /*#__PURE__*/_regeneratorRuntime.mark(__splitOnAnySeq);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../../internal/any-seq.js'),\n    seqsToArray = _require2.seqsToArray;\n\nvar _require3 = require('../$starts-with-seq/starts-with-seq.js'),\n    __startsWithSeq = _require3.__startsWithSeq;\n\nvar _require4 = require('../$window-ahead/window-ahead.js'),\n    __windowAhead = _require4.__windowAhead;\n\nvar _require5 = require('../$spliterate/spliterate.js'),\n    __spliterate = _require5.__spliterate;\n\nfunction getMatchingLength(buffer, separatorSeqs, same) {\n  var _iterator = _createForOfIteratorHelper(separatorSeqs),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var subsequence = _step.value;\n\n      if (__startsWithSeq(buffer, subsequence, same)) {\n        return subsequence.length;\n      }\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  return 0;\n}\n\nfunction anySeqspliterator(split, _ref, source) {\n  var separatorSeqs, same, maxMatchLength, skip, _iterator2, _step2, buffer, matchingLength;\n\n  return _regeneratorRuntime.wrap(function anySeqspliterator$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          separatorSeqs = _ref.separatorSeqs, same = _ref.same;\n          maxMatchLength = separatorSeqs.reduce(function (max, _ref2) {\n            var length = _ref2.length;\n            return Math.max(max, length);\n          }, 1);\n          skip = 0;\n          _iterator2 = _createForOfIteratorHelper(__windowAhead(source, maxMatchLength, {\n            useFiller: false\n          }));\n          _context.prev = 4;\n\n          _iterator2.s();\n\n        case 6:\n          if ((_step2 = _iterator2.n()).done) {\n            _context.next = 22;\n            break;\n          }\n\n          buffer = _step2.value;\n\n          if (!(skip > 0)) {\n            _context.next = 11;\n            break;\n          }\n\n          skip--;\n          return _context.abrupt(\"continue\", 20);\n\n        case 11:\n          matchingLength = getMatchingLength(buffer, separatorSeqs, same);\n\n          if (!(matchingLength > 0)) {\n            _context.next = 18;\n            break;\n          }\n\n          _context.next = 15;\n          return split;\n\n        case 15:\n          skip = matchingLength - 1;\n          _context.next = 20;\n          break;\n\n        case 18:\n          _context.next = 20;\n          return buffer.get(0);\n\n        case 20:\n          _context.next = 6;\n          break;\n\n        case 22:\n          _context.next = 27;\n          break;\n\n        case 24:\n          _context.prev = 24;\n          _context.t0 = _context[\"catch\"](4);\n\n          _iterator2.e(_context.t0);\n\n        case 27:\n          _context.prev = 27;\n\n          _iterator2.f();\n\n          return _context.finish(27);\n\n        case 30:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[4, 24, 27, 30]]);\n}\n\nfunction __splitOnAnySeq(source, separatorSeqs) {\n  var same,\n      separatorSeqsArr,\n      _args2 = arguments;\n  return _regeneratorRuntime.wrap(function __splitOnAnySeq$(_context2) {\n    while (1) {\n      switch (_context2.prev = _context2.next) {\n        case 0:\n          same = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : Object.is;\n          separatorSeqsArr = seqsToArray(separatorSeqs).filter(function (s) {\n            return s.length > 0;\n          });\n          return _context2.delegateYield(__spliterate(source, anySeqspliterator, {\n            separatorSeqs: separatorSeqsArr.sort(function (a, b) {\n              return b.length - a.length;\n            }),\n            same: same\n          }), \"t0\", 3);\n\n        case 3:\n        case \"end\":\n          return _context2.stop();\n      }\n    }\n  }, _marked2);\n}\n\nexports.__splitOnAnySeq = __splitOnAnySeq;\nvar splitOnAnySeq = /*#__PURE__*/iterableCurry(__splitOnAnySeq, {\n  minArgs: 1,\n  maxArgs: 2\n});\nexports.splitOnAnySeq = splitOnAnySeq;","var _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$split-when/async-split-when.js'),\n    __asyncSplitWhen = _require2.__asyncSplitWhen;\n\nvar _require3 = require('../$includes/includes.js'),\n    __includes = _require3.__includes;\n\nfunction __asyncSplitOnAny(source, separators) {\n  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;\n  return __asyncSplitWhen(source, function (value) {\n    return __includes(separators, value, function (a, b) {\n      return same(b, a);\n    });\n  });\n}\n\nexports.__asyncSplitOnAny = __asyncSplitOnAny;\nvar asyncSplitOnAny = /*#__PURE__*/asyncIterableCurry(__asyncSplitOnAny, {\n  minArgs: 1,\n  maxArgs: 2,\n  validateArgs: function validateArgs(args) {}\n});\nexports.asyncSplitOnAny = asyncSplitOnAny;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$split-when/split-when.js'),\n    __splitWhen = _require2.__splitWhen;\n\nvar _require3 = require('../$includes/includes.js'),\n    __includes = _require3.__includes;\n\nfunction __splitOnAny(source, separators) {\n  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;\n  return __splitWhen(source, function (value) {\n    return __includes(separators, value, function (a, b) {\n      return same(b, a);\n    });\n  });\n}\n\nexports.__splitOnAny = __splitOnAny;\nvar splitOnAny = /*#__PURE__*/iterableCurry(__splitOnAny, {\n  minArgs: 1,\n  maxArgs: 2,\n  validateArgs: function validateArgs(args) {\n    if (true && typeof args[0] === 'string') {\n      console.warn(\"For string inputs use splitOnAnySeq instead of splitOnAny\");\n    }\n  }\n});\nexports.splitOnAny = splitOnAny;","var _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry,\n    asyncEnsureIterable = _require.asyncEnsureIterable;\n\nvar _require2 = require('../$split-on-any-seq/async-split-on-any-seq.js'),\n    __asyncSplitOnAnySeq = _require2.__asyncSplitOnAnySeq;\n\nfunction __asyncSplitOnSeq(source, separatorSeq) {\n  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;\n  return __asyncSplitOnAnySeq(source, [separatorSeq], same);\n}\n\nexports.__asyncSplitOnSeq = __asyncSplitOnSeq;\nvar asyncSplitOnSeq = /*#__PURE__*/asyncIterableCurry(__asyncSplitOnSeq, {\n  minArgs: 1,\n  maxArgs: 2,\n  validateArgs: function validateArgs(args) {\n    args[1] = asyncEnsureIterable(args[1]);\n  }\n});\nexports.asyncSplitOnSeq = asyncSplitOnSeq;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry,\n    ensureIterable = _require.ensureIterable;\n\nvar _require2 = require('../$split-on-any-seq/split-on-any-seq.js'),\n    __splitOnAnySeq = _require2.__splitOnAnySeq;\n\nfunction __splitOnSeq(source, separatorSeq) {\n  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;\n  return __splitOnAnySeq(source, [separatorSeq], same);\n}\n\nexports.__splitOnSeq = __splitOnSeq;\nvar splitOnSeq = /*#__PURE__*/iterableCurry(__splitOnSeq, {\n  minArgs: 1,\n  maxArgs: 2,\n  validateArgs: function validateArgs(args) {\n    args[1] = ensureIterable(args[1]);\n  }\n});\nexports.splitOnSeq = splitOnSeq;","var _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$split-when/async-split-when.js'),\n    __asyncSplitWhen = _require2.__asyncSplitWhen;\n\nfunction __asyncSplitOn(source, separator) {\n  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;\n  return __asyncSplitWhen(source, function (value) {\n    return same(separator, value);\n  });\n}\n\nexports.__asyncSplitOn = __asyncSplitOn;\nvar asyncSplitOn = /*#__PURE__*/asyncIterableCurry(__asyncSplitOn, {\n  minArgs: 1,\n  maxArgs: 2,\n  validateArgs: function validateArgs(args) {}\n});\nexports.asyncSplitOn = asyncSplitOn;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$split-when/split-when.js'),\n    __splitWhen = _require2.__splitWhen;\n\nfunction __splitOn(source, separator) {\n  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;\n  return __splitWhen(source, function (value) {\n    return same(separator, value);\n  });\n}\n\nexports.__splitOn = __splitOn;\nvar splitOn = /*#__PURE__*/iterableCurry(__splitOn, {\n  minArgs: 1,\n  maxArgs: 2,\n  validateArgs: function validateArgs(args) {\n    if (true && typeof args[0] === 'string') {\n      console.warn(\"For string inputs use splitOnSeq instead of splitOn\");\n    }\n  }\n});\nexports.splitOn = splitOn;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$spliterate/async-spliterate.js'),\n    __asyncSpliterate = _require2.__asyncSpliterate;\n\nfunction asyncPredicateSpliterator(_x, _x2, _x3) {\n  return _asyncPredicateSpliterator.apply(this, arguments);\n}\n\nfunction _asyncPredicateSpliterator() {\n  _asyncPredicateSpliterator = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(split, _ref, source) {\n    var predicate, i, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            predicate = _ref.predicate;\n            i = 0;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 4;\n            _iterator = _asyncIterator(source);\n\n          case 6:\n            _context.next = 8;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 8:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 12;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 12:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 27;\n              break;\n            }\n\n            value = _value;\n            _context.next = 17;\n            return _awaitAsyncGenerator(predicate(value, i++));\n\n          case 17:\n            if (!_context.sent) {\n              _context.next = 21;\n              break;\n            }\n\n            _context.t0 = split;\n            _context.next = 22;\n            break;\n\n          case 21:\n            _context.t0 = value;\n\n          case 22:\n            _context.next = 24;\n            return _context.t0;\n\n          case 24:\n            _iteratorNormalCompletion = true;\n            _context.next = 6;\n            break;\n\n          case 27:\n            _context.next = 33;\n            break;\n\n          case 29:\n            _context.prev = 29;\n            _context.t1 = _context[\"catch\"](4);\n            _didIteratorError = true;\n            _iteratorError = _context.t1;\n\n          case 33:\n            _context.prev = 33;\n            _context.prev = 34;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 38;\n              break;\n            }\n\n            _context.next = 38;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 38:\n            _context.prev = 38;\n\n            if (!_didIteratorError) {\n              _context.next = 41;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 41:\n            return _context.finish(38);\n\n          case 42:\n            return _context.finish(33);\n\n          case 43:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[4, 29, 33, 43], [34,, 38, 42]]);\n  }));\n  return _asyncPredicateSpliterator.apply(this, arguments);\n}\n\nfunction __asyncSplitWhen(source, predicate) {\n  return __asyncSpliterate(source, asyncPredicateSpliterator, {\n    predicate: predicate\n  });\n}\n\nexports.__asyncSplitWhen = __asyncSplitWhen;\nvar asyncSplitWhen = /*#__PURE__*/asyncIterableCurry(__asyncSplitWhen);\nexports.asyncSplitWhen = asyncSplitWhen;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(predicateSpliterator);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$spliterate/spliterate.js'),\n    __spliterate = _require2.__spliterate;\n\nfunction predicateSpliterator(split, _ref, source) {\n  var predicate, i, _iterator, _step, value;\n\n  return _regeneratorRuntime.wrap(function predicateSpliterator$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          predicate = _ref.predicate;\n          i = 0;\n          _iterator = _createForOfIteratorHelper(source);\n          _context.prev = 3;\n\n          _iterator.s();\n\n        case 5:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 11;\n            break;\n          }\n\n          value = _step.value;\n          _context.next = 9;\n          return predicate(value, i++) ? split : value;\n\n        case 9:\n          _context.next = 5;\n          break;\n\n        case 11:\n          _context.next = 16;\n          break;\n\n        case 13:\n          _context.prev = 13;\n          _context.t0 = _context[\"catch\"](3);\n\n          _iterator.e(_context.t0);\n\n        case 16:\n          _context.prev = 16;\n\n          _iterator.f();\n\n          return _context.finish(16);\n\n        case 19:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[3, 13, 16, 19]]);\n}\n\nfunction __splitWhen(source, predicate) {\n  return __spliterate(source, predicateSpliterator, {\n    predicate: predicate\n  });\n}\n\nexports.__splitWhen = __splitWhen;\nvar splitWhen = /*#__PURE__*/iterableCurry(__splitWhen);\nexports.splitWhen = splitWhen;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(iterableOf);\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$map/async-map.js'),\n    __asyncMap = _require2.__asyncMap;\n\nfunction iterableOf(value) {\n  return _regeneratorRuntime.wrap(function iterableOf$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          _context.next = 2;\n          return value;\n\n        case 2:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nfunction __asyncSplit(source) {\n  return __asyncMap(source, function (value) {\n    return iterableOf(value);\n  });\n}\n\nexports.__asyncSplit = __asyncSplit;\nvar asyncSplit = /*#__PURE__*/asyncIterableCurry(__asyncSplit);\nexports.asyncSplit = asyncSplit;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(iterableOf);\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$map/map.js'),\n    __map = _require2.__map;\n\nfunction iterableOf(value) {\n  return _regeneratorRuntime.wrap(function iterableOf$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          _context.next = 2;\n          return value;\n\n        case 2:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nfunction __split(source) {\n  return __map(source, function (value) {\n    return iterableOf(value);\n  });\n}\n\nexports.__split = __split;\nvar split = /*#__PURE__*/iterableCurry(__split);\nexports.split = split;","var _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../../internal/async-groups-iterator.js'),\n    AsyncGroupsIterator = _require2.AsyncGroupsIterator;\n\nvar _require3 = require('../$map/async-map.js'),\n    __asyncMap = _require3.__asyncMap;\n\nvar _require4 = require('../$wrap/async-wrap.js'),\n    __asyncWrap = _require4.__asyncWrap;\n\nfunction __asyncSpliterateGrouped(source, strategy) {\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  return new AsyncGroupsIterator(source, strategy, options);\n}\n\nexports.__asyncSpliterateGrouped = __asyncSpliterateGrouped;\nvar asyncSpliterateGrouped = /*#__PURE__*/asyncIterableCurry(function $spliterateGrouped() {\n  return __asyncMap(__asyncSpliterateGrouped.apply(void 0, arguments), __asyncWrap);\n}, {\n  minArgs: 1,\n  maxArgs: 2,\n  growRight: true\n});\nexports.asyncSpliterateGrouped = asyncSpliterateGrouped;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../../internal/groups-iterator.js'),\n    GroupsIterator = _require2.GroupsIterator;\n\nvar _require3 = require('../$map/map.js'),\n    __map = _require3.__map;\n\nvar _require4 = require('../$wrap/wrap.js'),\n    __wrap = _require4.__wrap;\n\nfunction __spliterateGrouped(source, strategy) {\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  return new GroupsIterator(source, strategy, options);\n}\n\nexports.__spliterateGrouped = __spliterateGrouped;\nvar spliterateGrouped = /*#__PURE__*/iterableCurry(function $spliterateGrouped() {\n  return __map(__spliterateGrouped.apply(void 0, arguments), __wrap);\n}, {\n  minArgs: 1,\n  maxArgs: 2,\n  growRight: true\n});\nexports.spliterateGrouped = spliterateGrouped;","var _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../../internal/async-parts-iterator.js'),\n    AsyncPartsIterator = _require2.AsyncPartsIterator;\n\nvar _require3 = require('../$map/async-map.js'),\n    __asyncMap = _require3.__asyncMap;\n\nvar _require4 = require('../$wrap/async-wrap.js'),\n    __asyncWrap = _require4.__asyncWrap;\n\nfunction __asyncSpliterate(source, strategy) {\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  return new AsyncPartsIterator(source, strategy, options);\n}\n\nexports.__asyncSpliterate = __asyncSpliterate;\nvar asyncSpliterate = /*#__PURE__*/asyncIterableCurry(function $spliterate() {\n  return __asyncMap(__asyncSpliterate.apply(void 0, arguments), __asyncWrap);\n}, {\n  minArgs: 1,\n  maxArgs: 2,\n  growRight: true\n});\nexports.asyncSpliterate = asyncSpliterate;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../../internal/parts-iterator.js'),\n    PartsIterator = _require2.PartsIterator;\n\nvar _require3 = require('../$map/map.js'),\n    __map = _require3.__map;\n\nvar _require4 = require('../$wrap/wrap.js'),\n    __wrap = _require4.__wrap;\n\nfunction __spliterate(source, strategy) {\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  return new PartsIterator(source, strategy, options);\n}\n\nexports.__spliterate = __spliterate;\nvar spliterate = /*#__PURE__*/iterableCurry(function $spliterate() {\n  return __map(__spliterate.apply(void 0, arguments), __wrap);\n}, {\n  minArgs: 1,\n  maxArgs: 2,\n  growRight: true\n});\nexports.spliterate = spliterate;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry,\n    asyncEnsureIterable = _require.asyncEnsureIterable;\n\nvar _require2 = require('../$zip-all/async-zip-all.js'),\n    __asyncZipAll = _require2.__asyncZipAll;\n\nvar _require3 = require('../$peekerate/async-peekerate.js'),\n    __asyncPeekerate = _require3.__asyncPeekerate;\n\nvar none = Symbol('none');\n\nfunction _asyncStartsWithAnySeq(_x, _x2, _x3) {\n  return _asyncStartsWithAnySeq2.apply(this, arguments);\n}\n\nfunction _asyncStartsWithAnySeq2() {\n  _asyncStartsWithAnySeq2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(peekr, subseqPeekr, same) {\n    var matches, value, seqValue, i;\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            if (!(subseqPeekr.done || subseqPeekr.value.includes(none))) {\n              _context.next = 2;\n              break;\n            }\n\n            return _context.abrupt(\"return\", true);\n\n          case 2:\n            matches = subseqPeekr.value.map(function () {\n              return true;\n            });\n\n          case 3:\n            if (!(!peekr.done && !subseqPeekr.done)) {\n              _context.next = 22;\n              break;\n            }\n\n            value = peekr.value;\n            seqValue = subseqPeekr.value;\n            i = 0;\n\n          case 7:\n            if (!(i < seqValue.length)) {\n              _context.next = 18;\n              break;\n            }\n\n            if (matches[i]) {\n              _context.next = 10;\n              break;\n            }\n\n            return _context.abrupt(\"continue\", 15);\n\n          case 10:\n            if (!(seqValue[i] === none)) {\n              _context.next = 14;\n              break;\n            }\n\n            return _context.abrupt(\"return\", true);\n\n          case 14:\n            matches[i] = same(seqValue[i], value);\n\n          case 15:\n            i++;\n            _context.next = 7;\n            break;\n\n          case 18:\n            _context.next = 20;\n            return Promise.all([subseqPeekr.advance(), peekr.advance()]);\n\n          case 20:\n            _context.next = 3;\n            break;\n\n          case 22:\n            return _context.abrupt(\"return\", subseqPeekr.done && matches.includes(true));\n\n          case 23:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncStartsWithAnySeq2.apply(this, arguments);\n}\n\nexports._asyncStartsWithAnySeq = _asyncStartsWithAnySeq;\n\nfunction __asyncStartsWithAnySeq(_x4, _x5) {\n  return _asyncStartsWithAnySeq3.apply(this, arguments);\n}\n\nfunction _asyncStartsWithAnySeq3() {\n  _asyncStartsWithAnySeq3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(iterable, seqs) {\n    var same,\n        peekr,\n        subseqPeekr,\n        seqFound,\n        _args2 = arguments;\n    return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n      while (1) {\n        switch (_context2.prev = _context2.next) {\n          case 0:\n            same = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : Object.is;\n\n            if (seqs.length) {\n              _context2.next = 3;\n              break;\n            }\n\n            return _context2.abrupt(\"return\", false);\n\n          case 3:\n            _context2.next = 5;\n            return __asyncPeekerate(iterable);\n\n          case 5:\n            peekr = _context2.sent;\n            _context2.next = 8;\n            return __asyncPeekerate(__asyncZipAll(seqs, {\n              filler: none\n            }));\n\n          case 8:\n            subseqPeekr = _context2.sent;\n            _context2.next = 11;\n            return _asyncStartsWithAnySeq(peekr, subseqPeekr, same);\n\n          case 11:\n            seqFound = _context2.sent;\n            _context2.next = 14;\n            return subseqPeekr[\"return\"]();\n\n          case 14:\n            _context2.next = 16;\n            return peekr[\"return\"]();\n\n          case 16:\n            return _context2.abrupt(\"return\", seqFound);\n\n          case 17:\n          case \"end\":\n            return _context2.stop();\n        }\n      }\n    }, _callee2);\n  }));\n  return _asyncStartsWithAnySeq3.apply(this, arguments);\n}\n\nexports.__asyncStartsWithAnySeq = __asyncStartsWithAnySeq;\nvar asyncStartsWithAnySeq = /*#__PURE__*/asyncIterableCurry(__asyncStartsWithAnySeq, {\n  minArgs: 1,\n  maxArgs: 2,\n  reduces: true,\n  validateArgs: function validateArgs(args) {\n    args[1] = args[1].map(function (arg) {\n      return asyncEnsureIterable(arg);\n    });\n  }\n});\nexports.asyncStartsWithAnySeq = asyncStartsWithAnySeq;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry,\n    ensureIterable = _require.ensureIterable;\n\nvar _require2 = require('../$zip-all/zip-all.js'),\n    __zipAll = _require2.__zipAll;\n\nvar _require3 = require('../$peekerate/peekerate.js'),\n    __peekerate = _require3.__peekerate;\n\nvar none = Symbol('none');\n\nfunction _startsWithAnySeq(peekr, subseqPeekr, same) {\n  if (subseqPeekr.done || subseqPeekr.value.includes(none)) return true;\n  var matches = subseqPeekr.value.map(function () {\n    return true;\n  });\n\n  while (!peekr.done && !subseqPeekr.done) {\n    var value = peekr.value;\n    var seqValue = subseqPeekr.value;\n\n    for (var i = 0; i < seqValue.length; i++) {\n      if (!matches[i]) continue;\n\n      if (seqValue[i] === none) {\n        return true;\n      } else {\n        matches[i] = same(seqValue[i], value);\n      }\n    }\n\n    subseqPeekr.advance();\n    peekr.advance();\n  }\n\n  return subseqPeekr.done && matches.includes(true);\n}\n\nexports._startsWithAnySeq = _startsWithAnySeq;\n\nfunction __startsWithAnySeq(iterable, seqs) {\n  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;\n  if (!seqs.length) return false;\n\n  var peekr = __peekerate(iterable);\n\n  var subseqPeekr = __peekerate(__zipAll(seqs, {\n    filler: none\n  }));\n\n  var seqFound = _startsWithAnySeq(peekr, subseqPeekr, same);\n\n  subseqPeekr[\"return\"]();\n  peekr[\"return\"]();\n  return seqFound;\n}\n\nexports.__startsWithAnySeq = __startsWithAnySeq;\nvar startsWithAnySeq = /*#__PURE__*/iterableCurry(__startsWithAnySeq, {\n  minArgs: 1,\n  maxArgs: 2,\n  reduces: true,\n  validateArgs: function validateArgs(args) {\n    args[1] = args[1].map(function (arg) {\n      return ensureIterable(arg);\n    });\n  }\n});\nexports.startsWithAnySeq = startsWithAnySeq;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$first-or/async-first-or.js'),\n    __asyncFirstOr = _require2.__asyncFirstOr;\n\nvar _require3 = require('../$includes/includes.js'),\n    __includes = _require3.__includes;\n\nvar none = Symbol('none');\n\nfunction __asyncStartsWithAny(_x, _x2) {\n  return _asyncStartsWithAny.apply(this, arguments);\n}\n\nfunction _asyncStartsWithAny() {\n  _asyncStartsWithAny = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, values) {\n    var same,\n        first,\n        _args = arguments;\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            same = _args.length > 2 && _args[2] !== undefined ? _args[2] : Object.is;\n            _context.next = 3;\n            return __asyncFirstOr(iterable, none);\n\n          case 3:\n            first = _context.sent;\n\n            if (!(first === none)) {\n              _context.next = 6;\n              break;\n            }\n\n            return _context.abrupt(\"return\", false);\n\n          case 6:\n            return _context.abrupt(\"return\", __includes(values, first, function (a, b) {\n              return same(b, a);\n            }));\n\n          case 7:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncStartsWithAny.apply(this, arguments);\n}\n\nexports.__asyncStartsWithAny = __asyncStartsWithAny;\nvar asyncStartsWithAny = /*#__PURE__*/asyncIterableCurry(__asyncStartsWithAny, {\n  minArgs: 1,\n  maxArgs: 2,\n  reduces: true,\n  validateArgs: function validateArgs(args) {}\n});\nexports.asyncStartsWithAny = asyncStartsWithAny;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$first-or/first-or.js'),\n    __firstOr = _require2.__firstOr;\n\nvar _require3 = require('../$includes/includes.js'),\n    __includes = _require3.__includes;\n\nvar none = Symbol('none');\n\nfunction __startsWithAny(iterable, values) {\n  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;\n\n  var first = __firstOr(iterable, none);\n\n  if (first === none) return false;\n  return __includes(values, first, function (a, b) {\n    return same(b, a);\n  });\n}\n\nexports.__startsWithAny = __startsWithAny;\nvar startsWithAny = /*#__PURE__*/iterableCurry(__startsWithAny, {\n  minArgs: 1,\n  maxArgs: 2,\n  reduces: true,\n  validateArgs: function validateArgs(args) {\n    if (true && typeof args[0] === 'string') {\n      console.warn('For string inputs use startsWithAnySeq instead of startsWithAny');\n    }\n  }\n});\nexports.startsWithAny = startsWithAny;","var _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry,\n    asyncEnsureIterable = _require.asyncEnsureIterable;\n\nvar _require2 = require('../$starts-with-any-seq/async-starts-with-any-seq.js'),\n    __asyncStartsWithAnySeq = _require2.__asyncStartsWithAnySeq;\n\nfunction __asyncStartsWithSeq(iterable, seq) {\n  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;\n  return __asyncStartsWithAnySeq(iterable, [seq], same);\n}\n\nexports.__asyncStartsWithSeq = __asyncStartsWithSeq;\nvar asyncStartsWithSeq = /*#__PURE__*/asyncIterableCurry(__asyncStartsWithSeq, {\n  minArgs: 1,\n  maxArgs: 2,\n  reduces: true,\n  validateArgs: function validateArgs(args) {\n    args[1] = asyncEnsureIterable(args[1]);\n  }\n});\nexports.asyncStartsWithSeq = asyncStartsWithSeq;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry,\n    ensureIterable = _require.ensureIterable;\n\nvar _require2 = require('../$starts-with-any-seq/starts-with-any-seq.js'),\n    __startsWithAnySeq = _require2.__startsWithAnySeq;\n\nfunction __startsWithSeq(iterable, seq) {\n  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;\n  return __startsWithAnySeq(iterable, [seq], same);\n}\n\nexports.__startsWithSeq = __startsWithSeq;\nvar startsWithSeq = /*#__PURE__*/iterableCurry(__startsWithSeq, {\n  minArgs: 1,\n  maxArgs: 2,\n  reduces: true,\n  validateArgs: function validateArgs(args) {\n    args[1] = ensureIterable(args[1]);\n  }\n});\nexports.startsWithSeq = startsWithSeq;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$first-or/async-first-or.js'),\n    __asyncFirstOr = _require2.__asyncFirstOr;\n\nvar none = Symbol('none');\n\nfunction __asyncStartsWith(_x, _x2) {\n  return _asyncStartsWith.apply(this, arguments);\n}\n\nfunction _asyncStartsWith() {\n  _asyncStartsWith = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, value) {\n    var same,\n        first,\n        _args = arguments;\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            same = _args.length > 2 && _args[2] !== undefined ? _args[2] : Object.is;\n            _context.next = 3;\n            return __asyncFirstOr(iterable, none);\n\n          case 3:\n            first = _context.sent;\n\n            if (!(first === none)) {\n              _context.next = 6;\n              break;\n            }\n\n            return _context.abrupt(\"return\", false);\n\n          case 6:\n            return _context.abrupt(\"return\", same(value, first));\n\n          case 7:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncStartsWith.apply(this, arguments);\n}\n\nexports.__asyncStartsWith = __asyncStartsWith;\nvar asyncStartsWith = /*#__PURE__*/asyncIterableCurry(__asyncStartsWith, {\n  minArgs: 1,\n  maxArgs: 2,\n  reduces: true,\n  validateArgs: function validateArgs(args) {}\n});\nexports.asyncStartsWith = asyncStartsWith;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$first-or/first-or.js'),\n    __firstOr = _require2.__firstOr;\n\nvar none = Symbol('none');\n\nfunction __startsWith(iterable, value) {\n  var same = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Object.is;\n\n  var first = __firstOr(iterable, none);\n\n  if (first === none) return false;\n  return same(value, first);\n}\n\nexports.__startsWith = __startsWith;\nvar startsWith = /*#__PURE__*/iterableCurry(__startsWith, {\n  minArgs: 1,\n  maxArgs: 2,\n  reduces: true,\n  validateArgs: function validateArgs(args) {\n    if (true && typeof args[0] === 'string') {\n      console.warn('For string inputs use startsWithSeq instead of startsWith');\n    }\n  }\n});\nexports.startsWith = startsWith;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nfunction __asyncStr(_x) {\n  return _asyncStr.apply(this, arguments);\n}\n\nfunction _asyncStr() {\n  _asyncStr = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(chars) {\n    var result, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, _char;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            result = '';\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 3;\n            _iterator = _asyncIterator(chars);\n\n          case 5:\n            _context.next = 7;\n            return _iterator.next();\n\n          case 7:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 11;\n            return _step.value;\n\n          case 11:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 18;\n              break;\n            }\n\n            _char = _value;\n            result += _char.toString();\n\n          case 15:\n            _iteratorNormalCompletion = true;\n            _context.next = 5;\n            break;\n\n          case 18:\n            _context.next = 24;\n            break;\n\n          case 20:\n            _context.prev = 20;\n            _context.t0 = _context[\"catch\"](3);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 24:\n            _context.prev = 24;\n            _context.prev = 25;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 29;\n              break;\n            }\n\n            _context.next = 29;\n            return _iterator[\"return\"]();\n\n          case 29:\n            _context.prev = 29;\n\n            if (!_didIteratorError) {\n              _context.next = 32;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 32:\n            return _context.finish(29);\n\n          case 33:\n            return _context.finish(24);\n\n          case 34:\n            return _context.abrupt(\"return\", result);\n\n          case 35:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[3, 20, 24, 34], [25,, 29, 33]]);\n  }));\n  return _asyncStr.apply(this, arguments);\n}\n\nexports.__asyncStr = __asyncStr;\nvar asyncStr = /*#__PURE__*/asyncIterableCurry(__asyncStr, {\n  reduces: true\n});\nexports.asyncStr = asyncStr;","function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nfunction __str(chars) {\n  var result = '';\n\n  var _iterator = _createForOfIteratorHelper(chars),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var _char = _step.value;\n      result += _char.toString();\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  return result;\n}\n\nexports.__str = __str;\nvar str = /*#__PURE__*/iterableCurry(__str, {\n  reduces: true\n});\nexports.str = str;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nfunction __asyncTakeLastOr(_x, _x2) {\n  return _asyncTakeLastOr.apply(this, arguments);\n}\n\nfunction _asyncTakeLastOr() {\n  _asyncTakeLastOr = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, whenEmpty) {\n    var _value, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value2, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            _value = whenEmpty;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 3;\n            _iterator = _asyncIterator(iterable);\n\n          case 5:\n            _context.next = 7;\n            return _iterator.next();\n\n          case 7:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 11;\n            return _step.value;\n\n          case 11:\n            _value2 = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 18;\n              break;\n            }\n\n            value = _value2;\n            _value = value;\n\n          case 15:\n            _iteratorNormalCompletion = true;\n            _context.next = 5;\n            break;\n\n          case 18:\n            _context.next = 24;\n            break;\n\n          case 20:\n            _context.prev = 20;\n            _context.t0 = _context[\"catch\"](3);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 24:\n            _context.prev = 24;\n            _context.prev = 25;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 29;\n              break;\n            }\n\n            _context.next = 29;\n            return _iterator[\"return\"]();\n\n          case 29:\n            _context.prev = 29;\n\n            if (!_didIteratorError) {\n              _context.next = 32;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 32:\n            return _context.finish(29);\n\n          case 33:\n            return _context.finish(24);\n\n          case 34:\n            return _context.abrupt(\"return\", _value);\n\n          case 35:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[3, 20, 24, 34], [25,, 29, 33]]);\n  }));\n  return _asyncTakeLastOr.apply(this, arguments);\n}\n\nexports.__asyncTakeLastOr = __asyncTakeLastOr;\nvar asyncTakeLastOr = /*#__PURE__*/asyncIterableCurry(__asyncTakeLastOr, {\n  reduces: true\n});\nexports.asyncTakeLastOr = asyncTakeLastOr;","function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nfunction __takeLastOr(iterable, whenEmpty) {\n  var _value = whenEmpty;\n\n  var _iterator = _createForOfIteratorHelper(iterable),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var value = _step.value;\n      _value = value;\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  return _value;\n}\n\nexports.__takeLastOr = __takeLastOr;\nvar takeLastOr = /*#__PURE__*/iterableCurry(__takeLastOr, {\n  reduces: true\n});\nexports.takeLastOr = takeLastOr;","var _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../$take-last-or/async-take-last-or.js'),\n    __asyncTakeLastOr = _require2.__asyncTakeLastOr;\n\nfunction __asyncTakeLast(iterable) {\n  return __asyncTakeLastOr(iterable, undefined);\n}\n\nexports.__asyncTakeLast = __asyncTakeLast;\nvar asyncTakeLast = /*#__PURE__*/asyncIterableCurry(__asyncTakeLast, {\n  reduces: true\n});\nexports.asyncTakeLast = asyncTakeLast;","var _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../$take-last-or/take-last-or.js'),\n    __takeLastOr = _require2.__takeLastOr;\n\nfunction __takeLast(iterable) {\n  return __takeLastOr(iterable, undefined);\n}\n\nexports.__takeLast = __takeLast;\nvar takeLast = /*#__PURE__*/iterableCurry(__takeLast, {\n  reduces: true\n});\nexports.takeLast = takeLast;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../../internal/compare.js'),\n    defaultCompareOrder = _require2.defaultCompareOrder;\n\nvar _require3 = require('./internal/heap.js'),\n    Heap = _require3.Heap;\n\nfunction __asyncTakeSorted(_x) {\n  return _asyncTakeSorted.apply(this, arguments);\n}\n\nexports.__asyncTakeSorted = __asyncTakeSorted;\n\nfunction _asyncTakeSorted() {\n  _asyncTakeSorted = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source) {\n    var n,\n        compare,\n        heap,\n        _iteratorNormalCompletion,\n        _didIteratorError,\n        _iteratorError,\n        _iterator,\n        _step,\n        _value,\n        value,\n        _args = arguments;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            n = _args.length > 1 && _args[1] !== undefined ? _args[1] : Infinity;\n            compare = _args.length > 2 && _args[2] !== undefined ? _args[2] : defaultCompareOrder;\n            heap = new Heap(compare);\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 5;\n            _iterator = _asyncIterator(source);\n\n          case 7:\n            _context.next = 9;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 9:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 13;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 13:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 21;\n              break;\n            }\n\n            value = _value;\n            heap.push(value);\n\n            if (heap.size > n) {\n              heap.pop();\n            }\n\n          case 18:\n            _iteratorNormalCompletion = true;\n            _context.next = 7;\n            break;\n\n          case 21:\n            _context.next = 27;\n            break;\n\n          case 23:\n            _context.prev = 23;\n            _context.t0 = _context[\"catch\"](5);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 27:\n            _context.prev = 27;\n            _context.prev = 28;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 32;\n              break;\n            }\n\n            _context.next = 32;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 32:\n            _context.prev = 32;\n\n            if (!_didIteratorError) {\n              _context.next = 35;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 35:\n            return _context.finish(32);\n\n          case 36:\n            return _context.finish(27);\n\n          case 37:\n            if (!heap.size) {\n              _context.next = 42;\n              break;\n            }\n\n            _context.next = 40;\n            return heap.pop();\n\n          case 40:\n            _context.next = 37;\n            break;\n\n          case 42:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[5, 23, 27, 37], [28,, 32, 36]]);\n  }));\n  return _asyncTakeSorted.apply(this, arguments);\n}\n\nvar asyncTakeSorted = /*#__PURE__*/asyncIterableCurry(__asyncTakeSorted, {\n  minArgs: 0,\n  maxArgs: 2,\n  validateArgs: function validateArgs(args) {\n    if (typeof args[1] === 'function') {\n      var temp = args[2];\n      args[2] = args[1];\n      args[1] = temp;\n    }\n  }\n});\nexports.asyncTakeSorted = asyncTakeSorted;","var _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nfunction swap(arr, x, y) {\n  var tmp = arr[x];\n  arr[x] = arr[y];\n  arr[y] = tmp;\n}\n\nvar Heap = /*#__PURE__*/function () {\n  function Heap(compare) {\n    _classCallCheck(this, Heap);\n\n    this.compare = compare;\n    this.data = [];\n  }\n\n  _createClass(Heap, [{\n    key: \"_bubbleUp\",\n    value: function _bubbleUp(i) {\n      var data = this.data,\n          compare = this.compare;\n      var parentIndex;\n\n      while (i > 0) {\n        parentIndex = Heap.getParentIndex(i);\n\n        if (compare(data[i], data[parentIndex]) < 0) {\n          swap(this.data, i, parentIndex);\n          i = parentIndex;\n        } else {\n          return i;\n        }\n      }\n    }\n  }, {\n    key: \"_heapify\",\n    value: function _heapify(i) {\n      var data = this.data,\n          compare = this.compare;\n      var lIdx = Heap.getLeftIndex(i);\n      var rIdx = Heap.getRightIndex(i);\n      var leftIsSmaller = this.has(lIdx) ? compare(data[lIdx], data[i]) < 0 : false;\n      var rightIsSmaller = this.has(rIdx) ? compare(data[rIdx], data[i]) < 0 : false;\n\n      if (leftIsSmaller && rightIsSmaller) {\n        if (compare(data[lIdx], data[rIdx]) < 0) {\n          swap(this.data, lIdx, i);\n          return lIdx;\n        } else {\n          swap(this.data, rIdx, i);\n          return rIdx;\n        }\n      } else if (leftIsSmaller) {\n        swap(this.data, lIdx, i);\n        return lIdx;\n      } else if (rightIsSmaller) {\n        swap(this.data, rIdx, i);\n        return rIdx;\n      }\n    }\n  }, {\n    key: \"_bubbleDown\",\n    value: function _bubbleDown(i) {\n      var size = this.size;\n\n      while (i !== null && i < size) {\n        i = this._heapify(i);\n      }\n    }\n  }, {\n    key: \"push\",\n    value: function push(value) {\n      this.data.push(value);\n\n      this._bubbleUp(this.size - 1);\n    }\n  }, {\n    key: \"pop\",\n    value: function pop() {\n      if (!this.size) return;\n      var root = this.data[0];\n      var last = this.data.pop();\n\n      if (this.size > 0) {\n        this.data[0] = last;\n\n        this._bubbleDown(0);\n      }\n\n      return root;\n    }\n  }, {\n    key: \"has\",\n    value: function has(idx) {\n      return idx > 0 && idx < this.size;\n    }\n  }, {\n    key: \"size\",\n    get: function get() {\n      return this.data.length;\n    }\n  }], [{\n    key: \"getParentIndex\",\n    value: function getParentIndex(i) {\n      return i % 2 ? (i - 1) / 2 : Math.floor((i - 1) / 2);\n    }\n  }, {\n    key: \"getLeftIndex\",\n    value: function getLeftIndex(i) {\n      return 2 * i + 1;\n    }\n  }, {\n    key: \"getRightIndex\",\n    value: function getRightIndex(i) {\n      return 2 * i + 2;\n    }\n  }]);\n\n  return Heap;\n}();\n\nexports.Heap = Heap;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__takeSorted);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../../internal/compare.js'),\n    defaultCompareOrder = _require2.defaultCompareOrder;\n\nvar _require3 = require('./internal/heap.js'),\n    Heap = _require3.Heap;\n\nfunction __takeSorted(source) {\n  var n,\n      compare,\n      heap,\n      _iterator,\n      _step,\n      value,\n      _args = arguments;\n\n  return _regeneratorRuntime.wrap(function __takeSorted$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          n = _args.length > 1 && _args[1] !== undefined ? _args[1] : Infinity;\n          compare = _args.length > 2 && _args[2] !== undefined ? _args[2] : defaultCompareOrder;\n          heap = new Heap(compare);\n          _iterator = _createForOfIteratorHelper(source);\n\n          try {\n            for (_iterator.s(); !(_step = _iterator.n()).done;) {\n              value = _step.value;\n              heap.push(value);\n\n              if (heap.size > n) {\n                heap.pop();\n              }\n            }\n          } catch (err) {\n            _iterator.e(err);\n          } finally {\n            _iterator.f();\n          }\n\n        case 5:\n          if (!heap.size) {\n            _context.next = 10;\n            break;\n          }\n\n          _context.next = 8;\n          return heap.pop();\n\n        case 8:\n          _context.next = 5;\n          break;\n\n        case 10:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nexports.__takeSorted = __takeSorted;\nvar takeSorted = /*#__PURE__*/iterableCurry(__takeSorted, {\n  minArgs: 0,\n  maxArgs: 2,\n  validateArgs: function validateArgs(args) {\n    if (typeof args[1] === 'function') {\n      var temp = args[2];\n      args[2] = args[1];\n      args[1] = temp;\n    }\n  }\n});\nexports.takeSorted = takeSorted;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nfunction __asyncTakeWhile(_x, _x2) {\n  return _asyncTakeWhile.apply(this, arguments);\n}\n\nexports.__asyncTakeWhile = __asyncTakeWhile;\n\nfunction _asyncTakeWhile() {\n  _asyncTakeWhile = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, predicate) {\n    var take, c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            take = true;\n            c = 0;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 4;\n            _iterator = _asyncIterator(source);\n\n          case 6:\n            _context.next = 8;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 8:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 12;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 12:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 27;\n              break;\n            }\n\n            value = _value;\n            _context.next = 17;\n            return _awaitAsyncGenerator(predicate(value, c++));\n\n          case 17:\n            take = _context.sent;\n\n            if (!take) {\n              _context.next = 23;\n              break;\n            }\n\n            _context.next = 21;\n            return value;\n\n          case 21:\n            _context.next = 24;\n            break;\n\n          case 23:\n            return _context.abrupt(\"break\", 27);\n\n          case 24:\n            _iteratorNormalCompletion = true;\n            _context.next = 6;\n            break;\n\n          case 27:\n            _context.next = 33;\n            break;\n\n          case 29:\n            _context.prev = 29;\n            _context.t0 = _context[\"catch\"](4);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 33:\n            _context.prev = 33;\n            _context.prev = 34;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 38;\n              break;\n            }\n\n            _context.next = 38;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 38:\n            _context.prev = 38;\n\n            if (!_didIteratorError) {\n              _context.next = 41;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 41:\n            return _context.finish(38);\n\n          case 42:\n            return _context.finish(33);\n\n          case 43:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[4, 29, 33, 43], [34,, 38, 42]]);\n  }));\n  return _asyncTakeWhile.apply(this, arguments);\n}\n\nvar asyncTakeWhile = /*#__PURE__*/asyncIterableCurry(__asyncTakeWhile);\nexports.asyncTakeWhile = asyncTakeWhile;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__takeWhile);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nfunction __takeWhile(source, predicate) {\n  var take, c, _iterator, _step, value;\n\n  return _regeneratorRuntime.wrap(function __takeWhile$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          take = true;\n          c = 0;\n          _iterator = _createForOfIteratorHelper(source);\n          _context.prev = 3;\n\n          _iterator.s();\n\n        case 5:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 16;\n            break;\n          }\n\n          value = _step.value;\n          take = predicate(value, c++);\n\n          if (!take) {\n            _context.next = 13;\n            break;\n          }\n\n          _context.next = 11;\n          return value;\n\n        case 11:\n          _context.next = 14;\n          break;\n\n        case 13:\n          return _context.abrupt(\"break\", 16);\n\n        case 14:\n          _context.next = 5;\n          break;\n\n        case 16:\n          _context.next = 21;\n          break;\n\n        case 18:\n          _context.prev = 18;\n          _context.t0 = _context[\"catch\"](3);\n\n          _iterator.e(_context.t0);\n\n        case 21:\n          _context.prev = 21;\n\n          _iterator.f();\n\n          return _context.finish(21);\n\n        case 24:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[3, 18, 21, 24]]);\n}\n\nexports.__takeWhile = __takeWhile;\nvar takeWhile = /*#__PURE__*/iterableCurry(__takeWhile);\nexports.takeWhile = takeWhile;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nfunction __asyncTake(_x, _x2) {\n  return _asyncTake.apply(this, arguments);\n}\n\nexports.__asyncTake = __asyncTake;\n\nfunction _asyncTake() {\n  _asyncTake = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable, n) {\n    var i, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            if (!(n === 0)) {\n              _context.next = 2;\n              break;\n            }\n\n            return _context.abrupt(\"return\");\n\n          case 2:\n            i = 0;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 5;\n            _iterator = _asyncIterator(iterable);\n\n          case 7:\n            _context.next = 9;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 9:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 13;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 13:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 23;\n              break;\n            }\n\n            value = _value;\n            _context.next = 18;\n            return value;\n\n          case 18:\n            if (!(++i === n)) {\n              _context.next = 20;\n              break;\n            }\n\n            return _context.abrupt(\"break\", 23);\n\n          case 20:\n            _iteratorNormalCompletion = true;\n            _context.next = 7;\n            break;\n\n          case 23:\n            _context.next = 29;\n            break;\n\n          case 25:\n            _context.prev = 25;\n            _context.t0 = _context[\"catch\"](5);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 29:\n            _context.prev = 29;\n            _context.prev = 30;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 34;\n              break;\n            }\n\n            _context.next = 34;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 34:\n            _context.prev = 34;\n\n            if (!_didIteratorError) {\n              _context.next = 37;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 37:\n            return _context.finish(34);\n\n          case 38:\n            return _context.finish(29);\n\n          case 39:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[5, 25, 29, 39], [30,, 34, 38]]);\n  }));\n  return _asyncTake.apply(this, arguments);\n}\n\nvar asyncTake = /*#__PURE__*/asyncIterableCurry(__asyncTake);\nexports.asyncTake = asyncTake;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__take);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nfunction __take(iterable, n) {\n  var i, _iterator, _step, value;\n\n  return _regeneratorRuntime.wrap(function __take$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          if (!(n === 0)) {\n            _context.next = 2;\n            break;\n          }\n\n          return _context.abrupt(\"return\");\n\n        case 2:\n          i = 0;\n          _iterator = _createForOfIteratorHelper(iterable);\n          _context.prev = 4;\n\n          _iterator.s();\n\n        case 6:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 14;\n            break;\n          }\n\n          value = _step.value;\n          _context.next = 10;\n          return value;\n\n        case 10:\n          if (!(++i === n)) {\n            _context.next = 12;\n            break;\n          }\n\n          return _context.abrupt(\"break\", 14);\n\n        case 12:\n          _context.next = 6;\n          break;\n\n        case 14:\n          _context.next = 19;\n          break;\n\n        case 16:\n          _context.prev = 16;\n          _context.t0 = _context[\"catch\"](4);\n\n          _iterator.e(_context.t0);\n\n        case 19:\n          _context.prev = 19;\n\n          _iterator.f();\n\n          return _context.finish(19);\n\n        case 22:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[4, 16, 19, 22]]);\n}\n\nexports.__take = __take;\nvar take = /*#__PURE__*/iterableCurry(__take);\nexports.take = take;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nfunction __asyncTap(_x, _x2) {\n  return _asyncTap.apply(this, arguments);\n}\n\nexports.__asyncTap = __asyncTap;\n\nfunction _asyncTap() {\n  _asyncTap = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, callback) {\n    var c, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            c = 0;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 3;\n            _iterator = _asyncIterator(source);\n\n          case 5:\n            _context.next = 7;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 7:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 11;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 11:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 20;\n              break;\n            }\n\n            value = _value;\n            callback(value, c++);\n            _context.next = 17;\n            return value;\n\n          case 17:\n            _iteratorNormalCompletion = true;\n            _context.next = 5;\n            break;\n\n          case 20:\n            _context.next = 26;\n            break;\n\n          case 22:\n            _context.prev = 22;\n            _context.t0 = _context[\"catch\"](3);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 26:\n            _context.prev = 26;\n            _context.prev = 27;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 31;\n              break;\n            }\n\n            _context.next = 31;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 31:\n            _context.prev = 31;\n\n            if (!_didIteratorError) {\n              _context.next = 34;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 34:\n            return _context.finish(31);\n\n          case 35:\n            return _context.finish(26);\n\n          case 36:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[3, 22, 26, 36], [27,, 31, 35]]);\n  }));\n  return _asyncTap.apply(this, arguments);\n}\n\nvar asyncTap = /*#__PURE__*/asyncIterableCurry(__asyncTap);\nexports.asyncTap = asyncTap;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__tap);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nfunction __tap(source, callback) {\n  var c, _iterator, _step, value;\n\n  return _regeneratorRuntime.wrap(function __tap$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          c = 0;\n          _iterator = _createForOfIteratorHelper(source);\n          _context.prev = 2;\n\n          _iterator.s();\n\n        case 4:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 11;\n            break;\n          }\n\n          value = _step.value;\n          callback(value, c++);\n          _context.next = 9;\n          return value;\n\n        case 9:\n          _context.next = 4;\n          break;\n\n        case 11:\n          _context.next = 16;\n          break;\n\n        case 13:\n          _context.prev = 13;\n          _context.t0 = _context[\"catch\"](2);\n\n          _iterator.e(_context.t0);\n\n        case 16:\n          _context.prev = 16;\n\n          _iterator.f();\n\n          return _context.finish(16);\n\n        case 19:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[2, 13, 16, 19]]);\n}\n\nexports.__tap = __tap;\nvar tap = /*#__PURE__*/iterableCurry(__tap);\nexports.tap = tap;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncEnsureIterable = _require.asyncEnsureIterable;\n\nfunction __asyncToArray(_x) {\n  return _asyncToArray.apply(this, arguments);\n}\n\nfunction _asyncToArray() {\n  _asyncToArray = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source) {\n    var out, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            out = [];\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 3;\n            _iterator = _asyncIterator(source);\n\n          case 5:\n            _context.next = 7;\n            return _iterator.next();\n\n          case 7:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 11;\n            return _step.value;\n\n          case 11:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 18;\n              break;\n            }\n\n            value = _value;\n            out.push(value);\n\n          case 15:\n            _iteratorNormalCompletion = true;\n            _context.next = 5;\n            break;\n\n          case 18:\n            _context.next = 24;\n            break;\n\n          case 20:\n            _context.prev = 20;\n            _context.t0 = _context[\"catch\"](3);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 24:\n            _context.prev = 24;\n            _context.prev = 25;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 29;\n              break;\n            }\n\n            _context.next = 29;\n            return _iterator[\"return\"]();\n\n          case 29:\n            _context.prev = 29;\n\n            if (!_didIteratorError) {\n              _context.next = 32;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 32:\n            return _context.finish(29);\n\n          case 33:\n            return _context.finish(24);\n\n          case 34:\n            return _context.abrupt(\"return\", out);\n\n          case 35:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[3, 20, 24, 34], [25,, 29, 33]]);\n  }));\n  return _asyncToArray.apply(this, arguments);\n}\n\nexports.__asyncToArray = __asyncToArray;\n\nfunction asyncToArray(source) {\n  return __asyncToArray(asyncEnsureIterable(source));\n}\n\nexports.asyncToArray = asyncToArray;","function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    ensureIterable = _require.ensureIterable;\n\nfunction __toArray(source) {\n  var out = [];\n\n  var _iterator = _createForOfIteratorHelper(source),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var value = _step.value;\n      out.push(value);\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  return out;\n}\n\nexports.__toArray = __toArray;\n\nfunction toArray(source) {\n  return __toArray(ensureIterable(source));\n}\n\nexports.toArray = toArray;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _slicedToArray = require(\"@babel/runtime/helpers/slicedToArray\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncEnsureIterable = _require.asyncEnsureIterable;\n\nfunction __asyncToObject(_x) {\n  return _asyncToObject.apply(this, arguments);\n}\n\nfunction _asyncToObject() {\n  _asyncToObject = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterable) {\n    var proto,\n        obj,\n        _iteratorNormalCompletion,\n        _didIteratorError,\n        _iteratorError,\n        _iterator,\n        _step,\n        _value,\n        _value2,\n        _value3,\n        key,\n        value,\n        _args = arguments;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            proto = _args.length > 1 && _args[1] !== undefined ? _args[1] : Object.prototype;\n            obj = Object.create(proto);\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 4;\n            _iterator = _asyncIterator(iterable);\n\n          case 6:\n            _context.next = 8;\n            return _iterator.next();\n\n          case 8:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 12;\n            return _step.value;\n\n          case 12:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 19;\n              break;\n            }\n\n            _value2 = _value, _value3 = _slicedToArray(_value2, 2), key = _value3[0], value = _value3[1];\n            obj[key] = value;\n\n          case 16:\n            _iteratorNormalCompletion = true;\n            _context.next = 6;\n            break;\n\n          case 19:\n            _context.next = 25;\n            break;\n\n          case 21:\n            _context.prev = 21;\n            _context.t0 = _context[\"catch\"](4);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 25:\n            _context.prev = 25;\n            _context.prev = 26;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 30;\n              break;\n            }\n\n            _context.next = 30;\n            return _iterator[\"return\"]();\n\n          case 30:\n            _context.prev = 30;\n\n            if (!_didIteratorError) {\n              _context.next = 33;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 33:\n            return _context.finish(30);\n\n          case 34:\n            return _context.finish(25);\n\n          case 35:\n            return _context.abrupt(\"return\", obj);\n\n          case 36:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[4, 21, 25, 35], [26,, 30, 34]]);\n  }));\n  return _asyncToObject.apply(this, arguments);\n}\n\nexports.__asyncToObject = __asyncToObject;\n\nfunction asyncToObject(iterable, proto) {\n  return __asyncToObject(asyncEnsureIterable(iterable), proto);\n}\n\nexports.asyncToObject = asyncToObject;","var _slicedToArray = require(\"@babel/runtime/helpers/slicedToArray\");\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    ensureIterable = _require.ensureIterable;\n\nfunction __toObject(iterable) {\n  var proto = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Object.prototype;\n  var obj = Object.create(proto);\n\n  var _iterator = _createForOfIteratorHelper(iterable),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var _step$value = _slicedToArray(_step.value, 2),\n          key = _step$value[0],\n          value = _step$value[1];\n\n      obj[key] = value;\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  return obj;\n}\n\nexports.__toObject = __toObject;\n\nfunction toObject(iterable, proto) {\n  return __toObject(ensureIterable(iterable), proto);\n}\n\nexports.toObject = toObject;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../../internal/circular-buffer.js'),\n    CircularBuffer = _require2.CircularBuffer,\n    ReadOnlyCircularBuffer = _require2.ReadOnlyCircularBuffer;\n\nfunction __asyncWindowAhead(_x, _x2) {\n  return _asyncWindowAhead.apply(this, arguments);\n}\n\nexports.__asyncWindowAhead = __asyncWindowAhead;\n\nfunction _asyncWindowAhead() {\n  _asyncWindowAhead = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, size) {\n    var _ref,\n        _ref$filler,\n        filler,\n        _ref$useFiller,\n        useFiller,\n        buffer,\n        bufferReadProxy,\n        len,\n        _iteratorNormalCompletion,\n        _didIteratorError,\n        _iteratorError,\n        _iterator,\n        _step,\n        _value,\n        value,\n        i,\n        _i,\n        _args = arguments;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            _ref = _args.length > 2 && _args[2] !== undefined ? _args[2] : {}, _ref$filler = _ref.filler, filler = _ref$filler === void 0 ? undefined : _ref$filler, _ref$useFiller = _ref.useFiller, useFiller = _ref$useFiller === void 0 ? true : _ref$useFiller;\n            buffer = new CircularBuffer(size);\n            bufferReadProxy = new ReadOnlyCircularBuffer(buffer);\n            len = 0;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 6;\n            _iterator = _asyncIterator(source);\n\n          case 8:\n            _context.next = 10;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 10:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 14;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 14:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 25;\n              break;\n            }\n\n            value = _value;\n            buffer.push(value);\n\n            if (!buffer.isFull()) {\n              _context.next = 21;\n              break;\n            }\n\n            _context.next = 21;\n            return bufferReadProxy;\n\n          case 21:\n            len++;\n\n          case 22:\n            _iteratorNormalCompletion = true;\n            _context.next = 8;\n            break;\n\n          case 25:\n            _context.next = 31;\n            break;\n\n          case 27:\n            _context.prev = 27;\n            _context.t0 = _context[\"catch\"](6);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 31:\n            _context.prev = 31;\n            _context.prev = 32;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 36;\n              break;\n            }\n\n            _context.next = 36;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 36:\n            _context.prev = 36;\n\n            if (!_didIteratorError) {\n              _context.next = 39;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 39:\n            return _context.finish(36);\n\n          case 40:\n            return _context.finish(31);\n\n          case 41:\n            if (useFiller) {\n              for (i = len; i < size; i++) {\n                buffer.push(filler);\n              }\n            }\n\n            if (!(len > 0 && len < size)) {\n              _context.next = 45;\n              break;\n            }\n\n            _context.next = 45;\n            return bufferReadProxy;\n\n          case 45:\n            _i = 0;\n\n          case 46:\n            if (!(_i < Math.min(size, len) - 1)) {\n              _context.next = 54;\n              break;\n            }\n\n            buffer.shift();\n\n            if (useFiller) {\n              buffer.push(filler);\n            }\n\n            _context.next = 51;\n            return bufferReadProxy;\n\n          case 51:\n            _i++;\n            _context.next = 46;\n            break;\n\n          case 54:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[6, 27, 31, 41], [32,, 36, 40]]);\n  }));\n  return _asyncWindowAhead.apply(this, arguments);\n}\n\nvar asyncWindowAhead = /*#__PURE__*/asyncIterableCurry(__asyncWindowAhead, {\n  minArgs: 1,\n  maxArgs: 2,\n  validateArgs: function validateArgs(args) {\n    if (typeof args[1] !== 'number') {\n      throw new Error('asyncWindowAhead'.concat(\" must be passed a numeric size\"));\n    }\n  }\n});\nexports.asyncWindowAhead = asyncWindowAhead;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__windowAhead);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../../internal/circular-buffer.js'),\n    CircularBuffer = _require2.CircularBuffer,\n    ReadOnlyCircularBuffer = _require2.ReadOnlyCircularBuffer;\n\nfunction __windowAhead(source, size) {\n  var _ref,\n      _ref$filler,\n      filler,\n      _ref$useFiller,\n      useFiller,\n      buffer,\n      bufferReadProxy,\n      len,\n      _iterator,\n      _step,\n      value,\n      i,\n      _i,\n      _args = arguments;\n\n  return _regeneratorRuntime.wrap(function __windowAhead$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          _ref = _args.length > 2 && _args[2] !== undefined ? _args[2] : {}, _ref$filler = _ref.filler, filler = _ref$filler === void 0 ? undefined : _ref$filler, _ref$useFiller = _ref.useFiller, useFiller = _ref$useFiller === void 0 ? true : _ref$useFiller;\n          buffer = new CircularBuffer(size);\n          bufferReadProxy = new ReadOnlyCircularBuffer(buffer);\n          len = 0;\n          _iterator = _createForOfIteratorHelper(source);\n          _context.prev = 5;\n\n          _iterator.s();\n\n        case 7:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 16;\n            break;\n          }\n\n          value = _step.value;\n          buffer.push(value);\n\n          if (!buffer.isFull()) {\n            _context.next = 13;\n            break;\n          }\n\n          _context.next = 13;\n          return bufferReadProxy;\n\n        case 13:\n          len++;\n\n        case 14:\n          _context.next = 7;\n          break;\n\n        case 16:\n          _context.next = 21;\n          break;\n\n        case 18:\n          _context.prev = 18;\n          _context.t0 = _context[\"catch\"](5);\n\n          _iterator.e(_context.t0);\n\n        case 21:\n          _context.prev = 21;\n\n          _iterator.f();\n\n          return _context.finish(21);\n\n        case 24:\n          if (useFiller) {\n            for (i = len; i < size; i++) {\n              buffer.push(filler);\n            }\n          }\n\n          if (!(len > 0 && len < size)) {\n            _context.next = 28;\n            break;\n          }\n\n          _context.next = 28;\n          return bufferReadProxy;\n\n        case 28:\n          _i = 0;\n\n        case 29:\n          if (!(_i < Math.min(size, len) - 1)) {\n            _context.next = 37;\n            break;\n          }\n\n          buffer.shift();\n\n          if (useFiller) {\n            buffer.push(filler);\n          }\n\n          _context.next = 34;\n          return bufferReadProxy;\n\n        case 34:\n          _i++;\n          _context.next = 29;\n          break;\n\n        case 37:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[5, 18, 21, 24]]);\n}\n\nexports.__windowAhead = __windowAhead;\nvar windowAhead = /*#__PURE__*/iterableCurry(__windowAhead, {\n  minArgs: 1,\n  maxArgs: 2,\n  validateArgs: function validateArgs(args) {\n    if (typeof args[1] !== 'number') {\n      throw new Error('windowAhead'.concat(\" must be passed a numeric size\"));\n    }\n  }\n});\nexports.windowAhead = windowAhead;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../../internal/circular-buffer.js'),\n    CircularBuffer = _require2.CircularBuffer,\n    ReadOnlyCircularBuffer = _require2.ReadOnlyCircularBuffer;\n\nfunction __asyncWindowBehind(_x, _x2) {\n  return _asyncWindowBehind.apply(this, arguments);\n}\n\nexports.__asyncWindowBehind = __asyncWindowBehind;\n\nfunction _asyncWindowBehind() {\n  _asyncWindowBehind = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, size) {\n    var _ref,\n        filler,\n        buffer,\n        bufferReadProxy,\n        _iteratorNormalCompletion,\n        _didIteratorError,\n        _iteratorError,\n        _iterator,\n        _step,\n        _value,\n        value,\n        _args = arguments;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            _ref = _args.length > 2 && _args[2] !== undefined ? _args[2] : {}, filler = _ref.filler;\n            buffer = new CircularBuffer(size);\n            bufferReadProxy = new ReadOnlyCircularBuffer(buffer);\n            buffer.fill(filler);\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 6;\n            _iterator = _asyncIterator(source);\n\n          case 8:\n            _context.next = 10;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 10:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 14;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 14:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 23;\n              break;\n            }\n\n            value = _value;\n            buffer.push(value);\n            _context.next = 20;\n            return bufferReadProxy;\n\n          case 20:\n            _iteratorNormalCompletion = true;\n            _context.next = 8;\n            break;\n\n          case 23:\n            _context.next = 29;\n            break;\n\n          case 25:\n            _context.prev = 25;\n            _context.t0 = _context[\"catch\"](6);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 29:\n            _context.prev = 29;\n            _context.prev = 30;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 34;\n              break;\n            }\n\n            _context.next = 34;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 34:\n            _context.prev = 34;\n\n            if (!_didIteratorError) {\n              _context.next = 37;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 37:\n            return _context.finish(34);\n\n          case 38:\n            return _context.finish(29);\n\n          case 39:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[6, 25, 29, 39], [30,, 34, 38]]);\n  }));\n  return _asyncWindowBehind.apply(this, arguments);\n}\n\nvar asyncWindowBehind = /*#__PURE__*/asyncIterableCurry(__asyncWindowBehind, {\n  minArgs: 1,\n  maxArgs: 2,\n  validateArgs: function validateArgs(args) {\n    if (typeof args[1] !== 'number') {\n      throw new Error('asyncWindowBehind'.concat(\" must be passed a numeric size\"));\n    }\n  }\n});\nexports.asyncWindowBehind = asyncWindowBehind;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__windowBehind);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../../internal/circular-buffer.js'),\n    CircularBuffer = _require2.CircularBuffer,\n    ReadOnlyCircularBuffer = _require2.ReadOnlyCircularBuffer;\n\nfunction __windowBehind(source, size) {\n  var _ref,\n      filler,\n      buffer,\n      bufferReadProxy,\n      _iterator,\n      _step,\n      value,\n      _args = arguments;\n\n  return _regeneratorRuntime.wrap(function __windowBehind$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          _ref = _args.length > 2 && _args[2] !== undefined ? _args[2] : {}, filler = _ref.filler;\n          buffer = new CircularBuffer(size);\n          bufferReadProxy = new ReadOnlyCircularBuffer(buffer);\n          buffer.fill(filler);\n          _iterator = _createForOfIteratorHelper(source);\n          _context.prev = 5;\n\n          _iterator.s();\n\n        case 7:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 14;\n            break;\n          }\n\n          value = _step.value;\n          buffer.push(value);\n          _context.next = 12;\n          return bufferReadProxy;\n\n        case 12:\n          _context.next = 7;\n          break;\n\n        case 14:\n          _context.next = 19;\n          break;\n\n        case 16:\n          _context.prev = 16;\n          _context.t0 = _context[\"catch\"](5);\n\n          _iterator.e(_context.t0);\n\n        case 19:\n          _context.prev = 19;\n\n          _iterator.f();\n\n          return _context.finish(19);\n\n        case 22:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[5, 16, 19, 22]]);\n}\n\nexports.__windowBehind = __windowBehind;\nvar windowBehind = /*#__PURE__*/iterableCurry(__windowBehind, {\n  minArgs: 1,\n  maxArgs: 2,\n  validateArgs: function validateArgs(args) {\n    if (typeof args[1] !== 'number') {\n      throw new Error('windowBehind'.concat(\" must be passed a numeric size\"));\n    }\n  }\n});\nexports.windowBehind = windowBehind;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../../internal/circular-buffer.js'),\n    CircularBuffer = _require2.CircularBuffer,\n    ReadOnlyCircularBuffer = _require2.ReadOnlyCircularBuffer;\n\nfunction __asyncWindow(_x, _x2) {\n  return _asyncWindow.apply(this, arguments);\n}\n\nexports.__asyncWindow = __asyncWindow;\n\nfunction _asyncWindow() {\n  _asyncWindow = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, size) {\n    var buffer, bufferReadProxy, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            buffer = new CircularBuffer(size);\n            bufferReadProxy = new ReadOnlyCircularBuffer(buffer);\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 4;\n            _iterator = _asyncIterator(source);\n\n          case 6:\n            _context.next = 8;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 8:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 12;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 12:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 22;\n              break;\n            }\n\n            value = _value;\n            buffer.push(value);\n\n            if (!buffer.isFull()) {\n              _context.next = 19;\n              break;\n            }\n\n            _context.next = 19;\n            return bufferReadProxy;\n\n          case 19:\n            _iteratorNormalCompletion = true;\n            _context.next = 6;\n            break;\n\n          case 22:\n            _context.next = 28;\n            break;\n\n          case 24:\n            _context.prev = 24;\n            _context.t0 = _context[\"catch\"](4);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 28:\n            _context.prev = 28;\n            _context.prev = 29;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 33;\n              break;\n            }\n\n            _context.next = 33;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 33:\n            _context.prev = 33;\n\n            if (!_didIteratorError) {\n              _context.next = 36;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 36:\n            return _context.finish(33);\n\n          case 37:\n            return _context.finish(28);\n\n          case 38:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[4, 24, 28, 38], [29,, 33, 37]]);\n  }));\n  return _asyncWindow.apply(this, arguments);\n}\n\nvar asyncWindow = /*#__PURE__*/asyncIterableCurry(__asyncWindow, {\n  validateArgs: function validateArgs(args) {\n    if (typeof args[1] !== 'number') {\n      throw new Error('asyncWindow'.concat(\" must be passed a numeric size\"));\n    }\n  }\n});\nexports.asyncWindow = asyncWindow;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__window);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../../internal/circular-buffer.js'),\n    CircularBuffer = _require2.CircularBuffer,\n    ReadOnlyCircularBuffer = _require2.ReadOnlyCircularBuffer;\n\nfunction __window(source, size) {\n  var buffer, bufferReadProxy, _iterator, _step, value;\n\n  return _regeneratorRuntime.wrap(function __window$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          buffer = new CircularBuffer(size);\n          bufferReadProxy = new ReadOnlyCircularBuffer(buffer);\n          _iterator = _createForOfIteratorHelper(source);\n          _context.prev = 3;\n\n          _iterator.s();\n\n        case 5:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 13;\n            break;\n          }\n\n          value = _step.value;\n          buffer.push(value);\n\n          if (!buffer.isFull()) {\n            _context.next = 11;\n            break;\n          }\n\n          _context.next = 11;\n          return bufferReadProxy;\n\n        case 11:\n          _context.next = 5;\n          break;\n\n        case 13:\n          _context.next = 18;\n          break;\n\n        case 15:\n          _context.prev = 15;\n          _context.t0 = _context[\"catch\"](3);\n\n          _iterator.e(_context.t0);\n\n        case 18:\n          _context.prev = 18;\n\n          _iterator.f();\n\n          return _context.finish(18);\n\n        case 21:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[3, 15, 18, 21]]);\n}\n\nexports.__window = __window;\nvar window = /*#__PURE__*/iterableCurry(__window, {\n  validateArgs: function validateArgs(args) {\n    if (typeof args[1] !== 'number') {\n      throw new Error('window'.concat(\" must be passed a numeric size\"));\n    }\n  }\n});\nexports.window = window;","var _require = require('../../internal/async-iterable.js'),\n    asyncWrapWithIterableIterator = _require.asyncWrapWithIterableIterator;\n\nvar _require2 = require('../../internal/async-wrap.js'),\n    __asyncWrap = _require2.asyncNullableWrap;\n\nexports.__asyncWrap = __asyncWrap;\nvar asyncWrap = /*#__PURE__*/asyncWrapWithIterableIterator(__asyncWrap);\nexports.asyncWrap = asyncWrap;","var _require = require('../../internal/iterable.js'),\n    wrapWithIterableIterator = _require.wrapWithIterableIterator;\n\nvar _require2 = require('../../internal/wrap.js'),\n    __wrap = _require2.nullableWrap;\n\nexports.__wrap = __wrap;\nvar wrap = /*#__PURE__*/wrapWithIterableIterator(__wrap);\nexports.wrap = wrap;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../../internal/async-parallel-each.js'),\n    asyncParallelEach = _require2.asyncParallelEach;\n\nvar _require3 = require('../$peekerate/async-peekerate.js'),\n    __asyncPeekerate = _require3.__asyncPeekerate;\n\nvar _require4 = require('../$map/async-map.js'),\n    __asyncMap = _require4.__asyncMap;\n\nvar _require5 = require('../$every/every.js'),\n    __every = _require5.__every;\n\nvar _require6 = require('../$to-array/async-to-array.js'),\n    __asyncToArray = _require6.__asyncToArray;\n\nvar isDone = function isDone(peekr) {\n  return peekr.done;\n};\n\nfunction __asyncZipAll(_x) {\n  return _asyncZipAll.apply(this, arguments);\n}\n\nexports.__asyncZipAll = __asyncZipAll;\n\nfunction _asyncZipAll() {\n  _asyncZipAll = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(sources) {\n    var _ref,\n        filler,\n        peekrs,\n        done,\n        _args = arguments;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            _ref = _args.length > 1 && _args[1] !== undefined ? _args[1] : {}, filler = _ref.filler;\n            _context.next = 3;\n            return _awaitAsyncGenerator(__asyncToArray(__asyncMap(sources, __asyncPeekerate)));\n\n          case 3:\n            peekrs = _context.sent;\n            done = __every(peekrs, isDone);\n            _context.prev = 5;\n\n          case 6:\n            if (done) {\n              _context.next = 14;\n              break;\n            }\n\n            _context.next = 9;\n            return peekrs.map(function (_ref2) {\n              var value = _ref2.value,\n                  done = _ref2.done;\n              return done ? filler : value;\n            });\n\n          case 9:\n            _context.next = 11;\n            return _awaitAsyncGenerator(asyncParallelEach(peekrs, function (peekr) {\n              return peekr.advance();\n            }));\n\n          case 11:\n            done = __every(peekrs, isDone);\n            _context.next = 6;\n            break;\n\n          case 14:\n            _context.prev = 14;\n            _context.next = 17;\n            return _awaitAsyncGenerator(asyncParallelEach(peekrs, function (peekr) {\n              return peekr[\"return\"]();\n            }));\n\n          case 17:\n            return _context.finish(14);\n\n          case 18:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[5,, 14, 18]]);\n  }));\n  return _asyncZipAll.apply(this, arguments);\n}\n\nvar asyncZipAll = /*#__PURE__*/asyncIterableCurry(__asyncZipAll, {\n  variadic: true,\n  minArgs: 0,\n  maxArgs: 1\n});\nexports.asyncZipAll = asyncZipAll;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__zipAll);\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../../internal/parallel-each.js'),\n    parallelEach = _require2.parallelEach;\n\nvar _require3 = require('../$peekerate/peekerate.js'),\n    __peekerate = _require3.__peekerate;\n\nvar _require4 = require('../$map/map.js'),\n    __map = _require4.__map;\n\nvar _require5 = require('../$every/every.js'),\n    __every = _require5.__every;\n\nvar _require6 = require('../$to-array/to-array.js'),\n    __toArray = _require6.__toArray;\n\nvar isDone = function isDone(peekr) {\n  return peekr.done;\n};\n\nfunction __zipAll(sources) {\n  var _ref,\n      filler,\n      peekrs,\n      done,\n      _args = arguments;\n\n  return _regeneratorRuntime.wrap(function __zipAll$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          _ref = _args.length > 1 && _args[1] !== undefined ? _args[1] : {}, filler = _ref.filler;\n          peekrs = __toArray(__map(sources, __peekerate));\n          done = __every(peekrs, isDone);\n          _context.prev = 3;\n\n        case 4:\n          if (done) {\n            _context.next = 11;\n            break;\n          }\n\n          _context.next = 7;\n          return peekrs.map(function (_ref2) {\n            var value = _ref2.value,\n                done = _ref2.done;\n            return done ? filler : value;\n          });\n\n        case 7:\n          parallelEach(peekrs, function (peekr) {\n            return peekr.advance();\n          });\n          done = __every(peekrs, isDone);\n          _context.next = 4;\n          break;\n\n        case 11:\n          _context.prev = 11;\n          parallelEach(peekrs, function (peekr) {\n            return peekr[\"return\"]();\n          });\n          return _context.finish(11);\n\n        case 14:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[3,, 11, 14]]);\n}\n\nexports.__zipAll = __zipAll;\nvar zipAll = /*#__PURE__*/iterableCurry(__zipAll, {\n  variadic: true,\n  minArgs: 0,\n  maxArgs: 1\n});\nexports.zipAll = zipAll;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../../internal/async-parallel-each.js'),\n    asyncParallelEach = _require2.asyncParallelEach;\n\nvar _require3 = require('../$peekerate/async-peekerate.js'),\n    __asyncPeekerate = _require3.__asyncPeekerate;\n\nvar _require4 = require('../$map/async-map.js'),\n    __asyncMap = _require4.__asyncMap;\n\nvar _require5 = require('../$map/map.js'),\n    __map = _require5.__map;\n\nvar _require6 = require('../$some/some.js'),\n    __some = _require6.__some;\n\nvar _require7 = require('../$to-array/async-to-array.js'),\n    __asyncToArray = _require7.__asyncToArray;\n\nvar isDone = function isDone(peekr) {\n  return peekr.done;\n};\n\nfunction __asyncZip(_x) {\n  return _asyncZip.apply(this, arguments);\n}\n\nexports.__asyncZip = __asyncZip;\n\nfunction _asyncZip() {\n  _asyncZip = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(sources) {\n    var peekrs, done;\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            _context.next = 2;\n            return _awaitAsyncGenerator(__asyncToArray(__asyncMap(sources, __asyncPeekerate)));\n\n          case 2:\n            peekrs = _context.sent;\n            done = __some(peekrs, isDone);\n            _context.prev = 4;\n\n          case 5:\n            if (done) {\n              _context.next = 13;\n              break;\n            }\n\n            _context.next = 8;\n            return peekrs.map(function (_ref) {\n              var value = _ref.value;\n              return value;\n            });\n\n          case 8:\n            _context.next = 10;\n            return _awaitAsyncGenerator(Promise.all(__map(peekrs, function (peekr) {\n              return peekr.advance();\n            })));\n\n          case 10:\n            done = __some(peekrs, isDone);\n            _context.next = 5;\n            break;\n\n          case 13:\n            _context.prev = 13;\n            _context.next = 16;\n            return _awaitAsyncGenerator(asyncParallelEach(peekrs, function (peekr) {\n              return peekr[\"return\"]();\n            }));\n\n          case 16:\n            return _context.finish(13);\n\n          case 17:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[4,, 13, 17]]);\n  }));\n  return _asyncZip.apply(this, arguments);\n}\n\nvar asyncZip = /*#__PURE__*/asyncIterableCurry(__asyncZip, {\n  variadic: true\n});\nexports.asyncZip = asyncZip;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__zip);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar _require = require('../../internal/iterable.js'),\n    iterableCurry = _require.iterableCurry;\n\nvar _require2 = require('../../internal/parallel-each.js'),\n    parallelEach = _require2.parallelEach;\n\nvar _require3 = require('../$peekerate/peekerate.js'),\n    __peekerate = _require3.__peekerate;\n\nvar _require4 = require('../$map/map.js'),\n    __map = _require4.__map;\n\nvar _require5 = require('../$some/some.js'),\n    __some = _require5.__some;\n\nvar _require6 = require('../$to-array/to-array.js'),\n    __toArray = _require6.__toArray;\n\nvar isDone = function isDone(peekr) {\n  return peekr.done;\n};\n\nfunction __zip(sources) {\n  var peekrs, done, _iterator, _step, peekr;\n\n  return _regeneratorRuntime.wrap(function __zip$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          peekrs = __toArray(__map(sources, __peekerate));\n          done = __some(peekrs, isDone);\n          _context.prev = 2;\n\n        case 3:\n          if (done) {\n            _context.next = 11;\n            break;\n          }\n\n          _context.next = 6;\n          return peekrs.map(function (_ref) {\n            var value = _ref.value;\n            return value;\n          });\n\n        case 6:\n          _iterator = _createForOfIteratorHelper(peekrs);\n\n          try {\n            for (_iterator.s(); !(_step = _iterator.n()).done;) {\n              peekr = _step.value;\n              peekr.advance();\n            }\n          } catch (err) {\n            _iterator.e(err);\n          } finally {\n            _iterator.f();\n          }\n\n          done = __some(peekrs, isDone);\n          _context.next = 3;\n          break;\n\n        case 11:\n          _context.prev = 11;\n          parallelEach(peekrs, function (peekr) {\n            return peekr[\"return\"]();\n          });\n          return _context.finish(11);\n\n        case 14:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[2,, 11, 14]]);\n}\n\nexports.__zip = __zip;\nvar zip = /*#__PURE__*/iterableCurry(__zip, {\n  variadic: true\n});\nexports.zip = zip;","var _toConsumableArray = require(\"@babel/runtime/helpers/toConsumableArray\");\n\nvar _require = require('../../internal/curry.js'),\n    curry = _require.curry;\n\nfunction __apply(fn) {\n  var args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n  return fn.apply(void 0, _toConsumableArray(args === null ? [] : args));\n}\n\nexports.__apply = __apply;\nvar apply = /*#__PURE__*/curry(__apply, 2);\nexports.apply = apply;","function arrayFirstOr(whenEmpty, array) {\n  return array && array.length ? array[0] : whenEmpty;\n}\n\nexports.arrayFirstOr = arrayFirstOr;","function arrayFirst(array) {\n  return array != null ? array[0] : undefined;\n}\n\nexports.arrayFirst = arrayFirst;","exports.__arrayFromAsync = require('../$to-array/async-to-array.js').__asyncToArray;\nexports.arrayFromAsync = require('../$to-array/async-to-array.js').asyncToArray;","exports.__arrayFrom = require('../$to-array/to-array.js').__toArray;\nexports.arrayFrom = require('../$to-array/to-array.js').toArray;","function arrayLastOr(whenEmpty, array) {\n  return array && array.length ? array[array.length - 1] : whenEmpty;\n}\n\nexports.arrayLastOr = arrayLastOr;","function arrayLast(array) {\n  return array ? array[array.length - 1] : undefined;\n}\n\nexports.arrayLast = arrayLast;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__arrayReverse);\n\nvar _require = require('../../internal/iterable.js'),\n    wrapWithIterableIterator = _require.wrapWithIterableIterator;\n\nfunction __arrayReverse(source) {\n  var i;\n  return _regeneratorRuntime.wrap(function __arrayReverse$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          if (!(source == null)) {\n            _context.next = 2;\n            break;\n          }\n\n          return _context.abrupt(\"return\");\n\n        case 2:\n          i = source.length - 1;\n\n        case 3:\n          if (!(i >= 0)) {\n            _context.next = 9;\n            break;\n          }\n\n          _context.next = 6;\n          return source[i];\n\n        case 6:\n          i--;\n          _context.next = 3;\n          break;\n\n        case 9:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nexports.__arrayReverse = __arrayReverse;\nvar arrayReverse = /*#__PURE__*/wrapWithIterableIterator(__arrayReverse, {\n  validateArgs: function validateArgs(args) {\n    if (!(Array.isArray(args[0]) || typeof args[0] === 'string' || args[0] == null)) {\n      throw new Error('arrayReverse only works arrays and strings');\n    }\n  }\n});\nexports.arrayReverse = arrayReverse;","var _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar _inherits = require(\"@babel/runtime/helpers/inherits\");\n\nvar _possibleConstructorReturn = require(\"@babel/runtime/helpers/possibleConstructorReturn\");\n\nvar _getPrototypeOf = require(\"@babel/runtime/helpers/getPrototypeOf\");\n\nvar _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _require = require('../../internal/curry.js'),\n    curry = _require.curry;\n\nvar _require2 = require('../../internal/async-iterable.js'),\n    asyncCallReturn = _require2.asyncCallReturn;\n\nvar _require3 = require('../../internal/async-iterable-iterator.js'),\n    AsyncIterableIterator = _require3.AsyncIterableIterator;\n\nvar _require4 = require('../../internal/circular-buffer.js'),\n    CircularBuffer = _require4.CircularBuffer;\n\nvar _require5 = require('../../internal/number.js'),\n    isPositiveInteger = _require5.isPositiveInteger;\n\nvar _require6 = require('../is-async-iterable/is-async-iterable.js'),\n    isAsyncIterable = _require6.isAsyncIterable;\n\nvar _require7 = require('../../internal/iterable.js'),\n    isIterable = _require7.isIterable;\n\nfunction empty() {\n  return _empty.apply(this, arguments);\n}\n\nfunction _empty() {\n  _empty = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _empty.apply(this, arguments);\n}\n\nfunction getIterator(iterable) {\n  if (iterable == null) {\n    return empty();\n  } else if (isAsyncIterable(iterable)) {\n    return iterable[Symbol.asyncIterator]();\n  } else if (isIterable(iterable)) {\n    return iterable[Symbol.iterator]();\n  } else {\n    throw new Error(\"asyncBuffer expected an iterable but received \".concat(iterable, \".\"));\n  }\n}\n\nvar Bufferator = /*#__PURE__*/function (_AsyncIterableIterato) {\n  _inherits(Bufferator, _AsyncIterableIterato);\n\n  var _super = _createSuper(Bufferator);\n\n  function Bufferator(iterable, concurrency) {\n    var _this;\n\n    _classCallCheck(this, Bufferator);\n\n    _this = _super.call(this);\n    _this.iterator = getIterator(iterable);\n    _this.buffer = new CircularBuffer(concurrency);\n\n    while (!_this.buffer.isFull()) {\n      _this.buffer.push(Promise.resolve(_this.iterator.next()));\n    }\n\n    return _this;\n  }\n\n  _createClass(Bufferator, [{\n    key: \"next\",\n    value: function () {\n      var _next = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {\n        var buffer, iterator;\n        return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n          while (1) {\n            switch (_context2.prev = _context2.next) {\n              case 0:\n                buffer = this.buffer, iterator = this.iterator;\n                _context2.next = 3;\n                return buffer.push(Promise.resolve(iterator.next()));\n\n              case 3:\n                return _context2.abrupt(\"return\", _context2.sent);\n\n              case 4:\n              case \"end\":\n                return _context2.stop();\n            }\n          }\n        }, _callee2, this);\n      }));\n\n      function next() {\n        return _next.apply(this, arguments);\n      }\n\n      return next;\n    }()\n  }, {\n    key: \"return\",\n    value: function () {\n      var _return2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {\n        return _regeneratorRuntime.wrap(function _callee3$(_context3) {\n          while (1) {\n            switch (_context3.prev = _context3.next) {\n              case 0:\n                _context3.next = 2;\n                return asyncCallReturn(this.iterator);\n\n              case 2:\n                return _context3.abrupt(\"return\", _context3.sent);\n\n              case 3:\n              case \"end\":\n                return _context3.stop();\n            }\n          }\n        }, _callee3, this);\n      }));\n\n      function _return() {\n        return _return2.apply(this, arguments);\n      }\n\n      return _return;\n    }()\n  }]);\n\n  return Bufferator;\n}(AsyncIterableIterator);\n\nexports.Bufferator = Bufferator;\n\nfunction __asyncBuffer(source, n) {\n  return new Bufferator(source, n);\n}\n\nexports.__asyncBuffer = __asyncBuffer;\nvar asyncBuffer = /*#__PURE__*/curry(function asyncBuffer(n, source) {\n  if (n === undefined) return;\n\n  if (n !== Infinity && !isPositiveInteger(n)) {\n    throw new Error('Concurrency must be an integer > 0');\n  } else if (n > 1024) {\n    throw new Error('Concurrency argument to asyncBuffer must be <= 1024');\n  }\n\n  return __asyncBuffer(source, n);\n});\nexports.asyncBuffer = asyncBuffer;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('./internal/race-to.js'),\n    raceTo = _require2.raceTo;\n\nfunction __asyncInterleaveReady(_x) {\n  return _asyncInterleaveReady.apply(this, arguments);\n}\n\nexports.__asyncInterleaveReady = __asyncInterleaveReady;\n\nfunction _asyncInterleaveReady() {\n  _asyncInterleaveReady = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(sources) {\n    var iterators, stepPromises, ready, _loop;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context2) {\n      while (1) {\n        switch (_context2.prev = _context2.next) {\n          case 0:\n            iterators = sources.map(function (iterable) {\n              return iterable[Symbol.asyncIterator]();\n            });\n            stepPromises = iterators.map(function (iter, idx) {\n              return iter.next().then(function (step) {\n                return {\n                  idx: idx,\n                  step: step\n                };\n              });\n            });\n            _loop = /*#__PURE__*/_regeneratorRuntime.mark(function _loop() {\n              var _ready, idx, step;\n\n              return _regeneratorRuntime.wrap(function _loop$(_context) {\n                while (1) {\n                  switch (_context.prev = _context.next) {\n                    case 0:\n                      _ready = ready, idx = _ready.idx, step = _ready.step;\n                      _context.next = 3;\n                      return step.value;\n\n                    case 3:\n                      stepPromises[idx] = iterators[idx].next().then(function (step) {\n                        return {\n                          idx: idx,\n                          step: step\n                        };\n                      });\n\n                    case 4:\n                    case \"end\":\n                      return _context.stop();\n                  }\n                }\n              }, _loop);\n            });\n\n          case 3:\n            _context2.next = 5;\n            return _awaitAsyncGenerator(raceTo(function (_ref) {\n              var step = _ref.step;\n              return !step.done;\n            }, null, stepPromises));\n\n          case 5:\n            _context2.t0 = ready = _context2.sent;\n\n            if (!(_context2.t0 !== null)) {\n              _context2.next = 10;\n              break;\n            }\n\n            return _context2.delegateYield(_loop(), \"t1\", 8);\n\n          case 8:\n            _context2.next = 3;\n            break;\n\n          case 10:\n          case \"end\":\n            return _context2.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncInterleaveReady.apply(this, arguments);\n}\n\nvar asyncInterleaveReady = /*#__PURE__*/asyncIterableCurry(__asyncInterleaveReady, {\n  variadic: true\n});\nexports.asyncInterleaveReady = asyncInterleaveReady;","function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction raceTo(predicate, notFoundValue, promises) {\n  return new Promise(function (resolve, reject) {\n    var promiseCount = 0;\n    var settledPromiseCount = 0;\n    var resolved = false;\n    var rejected = false;\n\n    var _iterator = _createForOfIteratorHelper(promises),\n        _step;\n\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var promise = _step.value;\n        promise[\"catch\"](function (error) {\n          if (!rejected && !resolved) {\n            reject(error);\n            rejected = true;\n          }\n        }).then(function (result) {\n          settledPromiseCount++;\n\n          if (!resolved && !rejected) {\n            if (predicate(result)) {\n              resolve(result);\n              resolved = true;\n            } else if (settledPromiseCount === promiseCount) {\n              resolve(notFoundValue);\n            }\n          }\n        });\n        promiseCount++;\n      }\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\n    }\n  });\n}\n\nexports.raceTo = raceTo;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../../internal/async-iterable.js'),\n    asyncIterableCurry = _require.asyncIterableCurry;\n\nvar _require2 = require('../../internal/number.js'),\n    isPositiveInteger = _require2.isPositiveInteger;\n\nvar _require3 = require('../../internal/delay.js'),\n    delay = _require3.delay;\n\nfunction __asyncThrottle(_x, _x2) {\n  return _asyncThrottle.apply(this, arguments);\n}\n\nexports.__asyncThrottle = __asyncThrottle;\n\nfunction _asyncThrottle() {\n  _asyncThrottle = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source, intervalMs) {\n    var waitSince, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value, duration;\n\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            waitSince = 0;\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context.prev = 3;\n            _iterator = _asyncIterator(source);\n\n          case 5:\n            _context.next = 7;\n            return _awaitAsyncGenerator(_iterator.next());\n\n          case 7:\n            _step = _context.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context.next = 11;\n            return _awaitAsyncGenerator(_step.value);\n\n          case 11:\n            _value = _context.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context.next = 23;\n              break;\n            }\n\n            value = _value;\n            duration = intervalMs - (Date.now() - waitSince);\n            _context.next = 17;\n            return _awaitAsyncGenerator(duration > 0 && delay(duration));\n\n          case 17:\n            waitSince = Date.now();\n            _context.next = 20;\n            return value;\n\n          case 20:\n            _iteratorNormalCompletion = true;\n            _context.next = 5;\n            break;\n\n          case 23:\n            _context.next = 29;\n            break;\n\n          case 25:\n            _context.prev = 25;\n            _context.t0 = _context[\"catch\"](3);\n            _didIteratorError = true;\n            _iteratorError = _context.t0;\n\n          case 29:\n            _context.prev = 29;\n            _context.prev = 30;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context.next = 34;\n              break;\n            }\n\n            _context.next = 34;\n            return _awaitAsyncGenerator(_iterator[\"return\"]());\n\n          case 34:\n            _context.prev = 34;\n\n            if (!_didIteratorError) {\n              _context.next = 37;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 37:\n            return _context.finish(34);\n\n          case 38:\n            return _context.finish(29);\n\n          case 39:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee, null, [[3, 25, 29, 39], [30,, 34, 38]]);\n  }));\n  return _asyncThrottle.apply(this, arguments);\n}\n\nvar asyncThrottle = /*#__PURE__*/asyncIterableCurry(__asyncThrottle, {\n  validateArgs: function validateArgs(args) {\n    if (!isPositiveInteger(args[1], true)) {\n      throw new Error('intervalMs argument to asyncThrottle must be a number > 0');\n    }\n  }\n});\nexports.asyncThrottle = asyncThrottle;","function __call(fn) {\n  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    args[_key - 1] = arguments[_key];\n  }\n\n  return fn.apply(void 0, args);\n}\n\nexports.__call = __call;\nvar call = __call;\nexports.call = call;","var identity = function identity(x) {\n  return x;\n};\n\nfunction compose() {\n  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {\n    fns[_key] = arguments[_key];\n  }\n\n  if (!fns.length) fns = [identity];\n  return fns.reduce(function (f, g) {\n    return function (x) {\n      return f(g(x));\n    };\n  });\n}\n\nexports.compose = compose;","function execPipe(initial) {\n  for (var _len = arguments.length, fns = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    fns[_key - 1] = arguments[_key];\n  }\n\n  return fns.reduce(function (value, fn) {\n    return fn(value);\n  }, initial);\n}\n\nexports.execPipe = execPipe;","function firstHighest(best, value) {\n  return value > best;\n}\n\nexports.firstHighest = firstHighest;","function firstLowest(best, value) {\n  return value < best;\n}\n\nexports.firstLowest = firstLowest;","function getSize(sequence) {\n  if (sequence == null) {\n    return 0;\n  } else {\n    var size = sequence.size;\n\n    if (typeof size === 'number') {\n      return sequence.size;\n    } else if (Array.isArray(sequence)) {\n      return sequence.length;\n    }\n  }\n\n  throw new Error('The argument passed to getSize did not have a size');\n}\n\nexports.getSize = getSize;","var isArray = Array.isArray;\nexports.isArray = isArray;","var _require = require('../not-undefined/not-undefined.js'),\n    notUndefined = _require.notUndefined;\n\nfunction isAsyncIterable(value) {\n  return value != null && notUndefined(value[Symbol.asyncIterator]);\n}\n\nexports.isAsyncIterable = isAsyncIterable;","var _require = require('../not-undefined/not-undefined.js'),\n    notUndefined = _require.notUndefined;\n\nfunction isAsyncLoopable(value) {\n  return value != null && (notUndefined(value[Symbol.asyncIterator]) || notUndefined(value[Symbol.iterator]));\n}\n\nexports.isAsyncLoopable = isAsyncLoopable;","var _require = require('../not-undefined/not-undefined.js'),\n    notUndefined = _require.notUndefined;\n\nfunction isAsyncWrappable(value) {\n  return value == null || notUndefined(value[Symbol.asyncIterator]) || notUndefined(value[Symbol.iterator]);\n}\n\nexports.isAsyncWrappable = isAsyncWrappable;","var _require = require('../not-undefined/not-undefined.js'),\n    notUndefined = _require.notUndefined;\n\nfunction isIterable(value) {\n  return value != null && notUndefined(value[Symbol.iterator]);\n}\n\nexports.isIterable = isIterable;","exports.isLoopable = require('../is-iterable/is-iterable.js').isIterable;","function isNil(value) {\n  return value == null;\n}\n\nexports.isNil = isNil;","function isNull(value) {\n  return value === null;\n}\n\nexports.isNull = isNull;","var _typeof = require(\"@babel/runtime/helpers/typeof\");\n\nfunction isObject(value) {\n  return _typeof(value) === 'object' && value !== null;\n}\n\nexports.isObject = isObject;","function isString(value) {\n  return typeof value === 'string';\n}\n\nexports.isString = isString;","function isUndefined(value) {\n  return typeof value === 'undefined';\n}\n\nexports.isUndefined = isUndefined;","var _require = require('../not-undefined/not-undefined.js'),\n    notUndefined = _require.notUndefined;\n\nfunction isWrappable(value) {\n  return value == null || notUndefined(value[Symbol.iterator]);\n}\n\nexports.isWrappable = isWrappable;","function lastHighest(best, value) {\n  return value >= best;\n}\n\nexports.lastHighest = lastHighest;","function lastLowest(best, value) {\n  return value <= best;\n}\n\nexports.lastLowest = lastLowest;","var isArray = Array.isArray;\n\nfunction notArray(value) {\n  return !isArray(value);\n}\n\nexports.notArray = notArray;","var _require = require('../is-undefined/is-undefined.js'),\n    isUndefined = _require.isUndefined;\n\nfunction notAsyncIterable(value) {\n  return value == null || isUndefined(value[Symbol.asyncIterator]);\n}\n\nexports.notAsyncIterable = notAsyncIterable;","var _require = require('../is-undefined/is-undefined.js'),\n    isUndefined = _require.isUndefined;\n\nfunction notAsyncLoopable(value) {\n  return value == null || isUndefined(value[Symbol.asyncIterator]) && isUndefined(value[Symbol.iterator]);\n}\n\nexports.notAsyncLoopable = notAsyncLoopable;","var _require = require('../is-undefined/is-undefined.js'),\n    isUndefined = _require.isUndefined;\n\nfunction notAsyncWrappable(value) {\n  return value != null && isUndefined(value[Symbol.asyncIterator]) && isUndefined(value[Symbol.iterator]);\n}\n\nexports.notAsyncWrappable = notAsyncWrappable;","var _require = require('../is-undefined/is-undefined.js'),\n    isUndefined = _require.isUndefined;\n\nfunction notIterable(value) {\n  return value == null || isUndefined(value[Symbol.iterator]);\n}\n\nexports.notIterable = notIterable;","exports.notLoopable = require('../not-iterable/not-iterable.js').notIterable;","function notNil(value) {\n  return value != null;\n}\n\nexports.notNil = notNil;","function notNull(value) {\n  return value !== null;\n}\n\nexports.notNull = notNull;","var _typeof = require(\"@babel/runtime/helpers/typeof\");\n\nfunction notObject(value) {\n  return _typeof(value) !== 'object' || value === null;\n}\n\nexports.notObject = notObject;","function notString(value) {\n  return typeof value !== 'string';\n}\n\nexports.notString = notString;","function notUndefined(value) {\n  return typeof value !== 'undefined';\n}\n\nexports.notUndefined = notUndefined;","var _require = require('../is-undefined/is-undefined.js'),\n    isUndefined = _require.isUndefined;\n\nfunction notWrappable(value) {\n  return value != null && isUndefined(value[Symbol.iterator]);\n}\n\nexports.notWrappable = notWrappable;","var _typeof = require(\"@babel/runtime/helpers/typeof\");\n\nvar _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__objectEntries);\n\nvar _require = require('../../internal/iterable.js'),\n    wrapWithIterableIterator = _require.wrapWithIterableIterator;\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction __objectEntries(obj) {\n  var key;\n  return _regeneratorRuntime.wrap(function __objectEntries$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          if (!(obj == null)) {\n            _context.next = 2;\n            break;\n          }\n\n          return _context.abrupt(\"return\");\n\n        case 2:\n          _context.t0 = _regeneratorRuntime.keys(obj);\n\n        case 3:\n          if ((_context.t1 = _context.t0()).done) {\n            _context.next = 10;\n            break;\n          }\n\n          key = _context.t1.value;\n\n          if (!hasOwnProperty.call(obj, key)) {\n            _context.next = 8;\n            break;\n          }\n\n          _context.next = 8;\n          return [key, obj[key]];\n\n        case 8:\n          _context.next = 3;\n          break;\n\n        case 10:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nexports.__objectEntries = __objectEntries;\nvar objectEntries = /*#__PURE__*/wrapWithIterableIterator(__objectEntries, {\n  validateArgs: function validateArgs(args) {\n    if (!(args[0] == null || _typeof(args[0]) === 'object')) {\n      throw new Error('obj argument to objectEntries must be an object, null, or undefined');\n    }\n  }\n});\nexports.objectEntries = objectEntries;","exports.__objectFromAsync = require('../$to-object/async-to-object.js').__asyncToObject;\nexports.objectFromAsync = require('../$to-object/async-to-object.js').asyncToObject;","exports.__objectFrom = require('../$to-object/to-object.js').__toObject;\nexports.objectFrom = require('../$to-object/to-object.js').toObject;","var _typeof = require(\"@babel/runtime/helpers/typeof\");\n\nvar _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__objectKeys);\n\nvar _require = require('../../internal/iterable.js'),\n    wrapWithIterableIterator = _require.wrapWithIterableIterator;\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction __objectKeys(obj) {\n  var key;\n  return _regeneratorRuntime.wrap(function __objectKeys$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          if (!(obj == null)) {\n            _context.next = 2;\n            break;\n          }\n\n          return _context.abrupt(\"return\");\n\n        case 2:\n          _context.t0 = _regeneratorRuntime.keys(obj);\n\n        case 3:\n          if ((_context.t1 = _context.t0()).done) {\n            _context.next = 10;\n            break;\n          }\n\n          key = _context.t1.value;\n\n          if (!hasOwnProperty.call(obj, key)) {\n            _context.next = 8;\n            break;\n          }\n\n          _context.next = 8;\n          return key;\n\n        case 8:\n          _context.next = 3;\n          break;\n\n        case 10:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nexports.__objectKeys = __objectKeys;\nvar objectKeys = /*#__PURE__*/wrapWithIterableIterator(__objectKeys, {\n  validateArgs: function validateArgs(args) {\n    if (!(args[0] == null || _typeof(args[0]) === 'object')) {\n      throw new Error('obj argument to objectKeys must be an object, null, or undefined');\n    }\n  }\n});\nexports.objectKeys = objectKeys;","var _typeof = require(\"@babel/runtime/helpers/typeof\");\n\nvar _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__objectValues);\n\nvar _require = require('../../internal/iterable.js'),\n    wrapWithIterableIterator = _require.wrapWithIterableIterator;\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction __objectValues(obj) {\n  var key;\n  return _regeneratorRuntime.wrap(function __objectValues$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          if (!(obj == null)) {\n            _context.next = 2;\n            break;\n          }\n\n          return _context.abrupt(\"return\");\n\n        case 2:\n          _context.t0 = _regeneratorRuntime.keys(obj);\n\n        case 3:\n          if ((_context.t1 = _context.t0()).done) {\n            _context.next = 10;\n            break;\n          }\n\n          key = _context.t1.value;\n\n          if (!hasOwnProperty.call(obj, key)) {\n            _context.next = 8;\n            break;\n          }\n\n          _context.next = 8;\n          return obj[key];\n\n        case 8:\n          _context.next = 3;\n          break;\n\n        case 10:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nexports.__objectValues = __objectValues;\nvar objectValues = /*#__PURE__*/wrapWithIterableIterator(__objectValues, {\n  validateArgs: function validateArgs(args) {\n    if (!(args[0] == null || _typeof(args[0]) === 'object')) {\n      throw new Error('obj argument to objectValues must be an object, null, or undefined');\n    }\n  }\n});\nexports.objectValues = objectValues;","var identity = function identity(x) {\n  return x;\n};\n\nfunction pipe() {\n  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {\n    fns[_key] = arguments[_key];\n  }\n\n  if (!fns.length) fns = [identity];\n  return fns.reduce(function (f, g) {\n    return function () {\n      return g(f.apply(void 0, arguments));\n    };\n  });\n}\n\nexports.pipe = pipe;","var _slicedToArray = require(\"@babel/runtime/helpers/slicedToArray\");\n\nvar _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__range);\n\nvar _require = require('../../internal/iterable.js'),\n    wrapWithIterableIterator = _require.wrapWithIterableIterator;\n\nvar _require2 = require('../../internal/number.js'),\n    isInteger = _require2.isInteger,\n    isIntegerOrInfinite = _require2.isIntegerOrInfinite;\n\nvar _require3 = require('../is-object/is-object.js'),\n    isObject = _require3.isObject;\n\nvar _require4 = require('../not-undefined/not-undefined.js'),\n    notUndefined = _require4.notUndefined;\n\nfunction __range() {\n  var start,\n      end,\n      step,\n      i,\n      _args = arguments;\n  return _regeneratorRuntime.wrap(function __range$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          start = _args.length > 0 && _args[0] !== undefined ? _args[0] : 0;\n          end = _args.length > 1 && _args[1] !== undefined ? _args[1] : Infinity;\n          step = _args.length > 2 && _args[2] !== undefined ? _args[2] : 1;\n          i = start;\n\n        case 4:\n          if (!(step > 0 ? i < end : i > end)) {\n            _context.next = 10;\n            break;\n          }\n\n          _context.next = 7;\n          return i;\n\n        case 7:\n          i += step;\n          _context.next = 4;\n          break;\n\n        case 10:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nexports.__range = __range;\nvar range = /*#__PURE__*/wrapWithIterableIterator(__range, {\n  growRight: true,\n  validateArgs: function validateArgs(args) {\n    var _args2 = _slicedToArray(args, 3),\n        optsOrEndOrStart = _args2[0],\n        _args2$ = _args2[1],\n        end = _args2$ === void 0 ? Infinity : _args2$,\n        step = _args2[2];\n\n    var start;\n\n    if (isObject(optsOrEndOrStart)) {\n      start = optsOrEndOrStart.start;\n      end = optsOrEndOrStart.end;\n      step = optsOrEndOrStart.step;\n    } else {\n      if (args.length > 1) {\n        start = optsOrEndOrStart;\n      } else {\n        end = optsOrEndOrStart;\n      }\n    }\n\n    if (notUndefined(start) && !isInteger(start)) {\n      throw new TypeError('The specified start was not an integer');\n    }\n\n    if (notUndefined(end) && !isIntegerOrInfinite(end)) {\n      throw new TypeError('The specified end was not an integer or infinite');\n    }\n\n    if (notUndefined(step) && !isInteger(step, true)) {\n      throw new TypeError('The specified step was not a non-zero integer');\n    }\n\n    args[0] = start;\n    args[1] = end;\n    args[2] = step;\n  }\n});\nexports.range = range;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__repeatTimes);\n\nvar _require = require('../../internal/curry.js'),\n    curry = _require.curry;\n\nvar _require2 = require('../../internal/iterable.js'),\n    wrapWithIterableIterator = _require2.wrapWithIterableIterator;\n\nfunction __repeatTimes(n, value) {\n  return _regeneratorRuntime.wrap(function __repeatTimes$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          if (!n--) {\n            _context.next = 5;\n            break;\n          }\n\n          _context.next = 3;\n          return value;\n\n        case 3:\n          _context.next = 0;\n          break;\n\n        case 5:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nexports.__repeatTimes = __repeatTimes;\nvar repeatTimes = /*#__PURE__*/curry( /*#__PURE__*/wrapWithIterableIterator(__repeatTimes), __repeatTimes.length);\nexports.repeatTimes = repeatTimes;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__repeat);\n\nvar _require = require('../../internal/iterable.js'),\n    wrapWithIterableIterator = _require.wrapWithIterableIterator;\n\nfunction __repeat(value) {\n  return _regeneratorRuntime.wrap(function __repeat$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          if (!true) {\n            _context.next = 5;\n            break;\n          }\n\n          _context.next = 3;\n          return value;\n\n        case 3:\n          _context.next = 0;\n          break;\n\n        case 5:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nexports.__repeat = __repeat;\nvar repeat = /*#__PURE__*/wrapWithIterableIterator(__repeat);\nexports.repeat = repeat;","exports.__stringFromAsync = require('../$str/async-str.js').__asyncStr;\nexports.stringFromAsync = require('../$str/async-str.js').asyncStr;","exports.__stringFrom = require('../$str/str.js').__str;\nexports.stringFrom = require('../$str/str.js').str;","var _typeof = require(\"@babel/runtime/helpers/typeof\");\n\nvar _defineProperty = require(\"@babel/runtime/helpers/defineProperty\");\n\nvar emptyIterator = {\n  next: function next() {\n    return {\n      value: undefined,\n      done: true\n    };\n  }\n};\nvar emptySpreadable = Object.freeze(Object.create(_defineProperty({}, Symbol.iterator, function () {\n  return emptyIterator;\n})));\n\nfunction when(condition, value) {\n  var valueType = _typeof(value);\n\n  if (!(value == null || value[Symbol.iterator] || valueType === 'object' || valueType === 'function')) {\n    throw new Error('Second argument to when must be an object, iterable, or function.');\n  }\n\n  return condition && value != null ? valueType === 'function' ? value() : value : emptySpreadable;\n}\n\nexports.when = when;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__wrapEntries);\n\nvar _require = require('../../internal/iterable.js'),\n    wrapWithIterableIterator = _require.wrapWithIterableIterator;\n\nfunction __wrapEntries(entriesable) {\n  return _regeneratorRuntime.wrap(function __wrapEntries$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          if (!(entriesable != null)) {\n            _context.next = 2;\n            break;\n          }\n\n          return _context.delegateYield(entriesable.entries(), \"t0\", 2);\n\n        case 2:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nexports.__wrapEntries = __wrapEntries;\nvar wrapEntries = /*#__PURE__*/wrapWithIterableIterator(__wrapEntries);\nexports.wrapEntries = wrapEntries;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__wrapKeys);\n\nvar _require = require('../../internal/iterable.js'),\n    wrapWithIterableIterator = _require.wrapWithIterableIterator;\n\nfunction __wrapKeys(keysable) {\n  return _regeneratorRuntime.wrap(function __wrapKeys$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          if (!(keysable != null)) {\n            _context.next = 2;\n            break;\n          }\n\n          return _context.delegateYield(keysable.keys(), \"t0\", 2);\n\n        case 2:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nexports.__wrapKeys = __wrapKeys;\nvar wrapKeys = /*#__PURE__*/wrapWithIterableIterator(__wrapKeys);\nexports.wrapKeys = wrapKeys;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(__wrapValues);\n\nvar _require = require('../../internal/iterable.js'),\n    wrapWithIterableIterator = _require.wrapWithIterableIterator;\n\nfunction __wrapValues(valuesable) {\n  return _regeneratorRuntime.wrap(function __wrapValues$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          if (!(valuesable != null)) {\n            _context.next = 2;\n            break;\n          }\n\n          return _context.delegateYield(valuesable.values(), \"t0\", 2);\n\n        case 2:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nexports.__wrapValues = __wrapValues;\nvar wrapValues = /*#__PURE__*/wrapWithIterableIterator(__wrapValues);\nexports.wrapValues = wrapValues;","exports.__append = require('./__methods/append.js');\nexports.__apply = require('./__methods/apply.js');\nexports.__arrayReverse = require('./__methods/array-reverse.js');\nexports.__asyncAppend = require('./__methods/async-append.js');\nexports.__asyncBatch = require('./__methods/async-batch.js');\nexports.__asyncBisect = require('./__methods/async-bisect.js');\nexports.__asyncBuffer = require('./__methods/async-buffer.js');\nexports.__asyncCollate = require('./__methods/async-collate.js');\nexports.__asyncCompress = require('./__methods/async-compress.js');\nexports.__asyncConcat = require('./__methods/async-concat.js');\nexports.__asyncConsume = require('./__methods/async-consume.js');\nexports.__asyncCycle = require('./__methods/async-cycle.js');\nexports.__asyncCycleTimes = require('./__methods/async-cycle-times.js');\nexports.__asyncDeepEqual = require('./__methods/async-deep-equal.js');\nexports.__asyncDistinct = require('./__methods/async-distinct.js');\nexports.__asyncDrop = require('./__methods/async-drop.js');\nexports.__asyncDropWhile = require('./__methods/async-drop-while.js');\nexports.__asyncEnumerate = require('./__methods/async-enumerate.js');\nexports.__asyncEqual = require('./__methods/async-equal.js');\nexports.__asyncEvery = require('./__methods/async-every.js');\nexports.__asyncFilter = require('./__methods/async-filter.js');\nexports.__asyncFind = require('./__methods/async-find.js');\nexports.__asyncFindBest = require('./__methods/async-find-best.js');\nexports.__asyncFindBestOr = require('./__methods/async-find-best-or.js');\nexports.__asyncFindOr = require('./__methods/async-find-or.js');\nexports.__asyncFirst = require('./__methods/async-first.js');\nexports.__asyncFirstOr = require('./__methods/async-first-or.js');\nexports.__asyncFlat = require('./__methods/async-flat.js');\nexports.__asyncFlatMap = require('./__methods/async-flat-map.js');\nexports.__asyncForEach = require('./__methods/async-for-each.js');\nexports.__asyncFork = require('./__methods/async-fork.js');\nexports.__asyncForkerate = require('./__methods/async-forkerate.js');\nexports.__asyncIncludes = require('./__methods/async-includes.js');\nexports.__asyncIncludesAny = require('./__methods/async-includes-any.js');\nexports.__asyncIncludesAnySeq = require('./__methods/async-includes-any-seq.js');\nexports.__asyncIncludesSeq = require('./__methods/async-includes-seq.js');\nexports.__asyncInterleave = require('./__methods/async-interleave.js');\nexports.__asyncInterleaveReady = require('./__methods/async-interleave-ready.js');\nexports.__asyncInterpose = require('./__methods/async-interpose.js');\nexports.__asyncInterposeSeq = require('./__methods/async-interpose-seq.js');\nexports.__asyncIsEmpty = require('./__methods/async-is-empty.js');\nexports.__asyncIsSorted = require('./__methods/async-is-sorted.js');\nexports.__asyncJoin = require('./__methods/async-join.js');\nexports.__asyncJoinWith = require('./__methods/async-join-with.js');\nexports.__asyncJoinWithSeq = require('./__methods/async-join-with-seq.js');\nexports.__asyncMap = require('./__methods/async-map.js');\nexports.__asyncPeekerate = require('./__methods/async-peekerate.js');\nexports.__asyncPrepend = require('./__methods/async-prepend.js');\nexports.__asyncReduce = require('./__methods/async-reduce.js');\nexports.__asyncReverse = require('./__methods/async-reverse.js');\nexports.__asyncRoundRobin = require('./__methods/async-round-robin.js');\nexports.__asyncSize = require('./__methods/async-size.js');\nexports.__asyncSlice = require('./__methods/async-slice.js');\nexports.__asyncSome = require('./__methods/async-some.js');\nexports.__asyncSplit = require('./__methods/async-split.js');\nexports.__asyncSplitGroups = require('./__methods/async-split-groups.js');\nexports.__asyncSplitOn = require('./__methods/async-split-on.js');\nexports.__asyncSplitOnAny = require('./__methods/async-split-on-any.js');\nexports.__asyncSplitOnAnySeq = require('./__methods/async-split-on-any-seq.js');\nexports.__asyncSplitOnSeq = require('./__methods/async-split-on-seq.js');\nexports.__asyncSplitWhen = require('./__methods/async-split-when.js');\nexports.__asyncSpliterate = require('./__methods/async-spliterate.js');\nexports.__asyncSpliterateGrouped = require('./__methods/async-spliterate-grouped.js');\nexports.__asyncStartsWith = require('./__methods/async-starts-with.js');\nexports.__asyncStartsWithAny = require('./__methods/async-starts-with-any.js');\nexports.__asyncStartsWithAnySeq = require('./__methods/async-starts-with-any-seq.js');\nexports.__asyncStartsWithSeq = require('./__methods/async-starts-with-seq.js');\nexports.__asyncStr = require('./__methods/async-str.js');\nexports.__asyncTake = require('./__methods/async-take.js');\nexports.__asyncTakeLast = require('./__methods/async-take-last.js');\nexports.__asyncTakeLastOr = require('./__methods/async-take-last-or.js');\nexports.__asyncTakeSorted = require('./__methods/async-take-sorted.js');\nexports.__asyncTakeWhile = require('./__methods/async-take-while.js');\nexports.__asyncTap = require('./__methods/async-tap.js');\nexports.__asyncThrottle = require('./__methods/async-throttle.js');\nexports.__asyncToArray = require('./__methods/async-to-array.js');\nexports.__asyncToObject = require('./__methods/async-to-object.js');\nexports.__asyncWindow = require('./__methods/async-window.js');\nexports.__asyncWindowAhead = require('./__methods/async-window-ahead.js');\nexports.__asyncWindowBehind = require('./__methods/async-window-behind.js');\nexports.__asyncZip = require('./__methods/async-zip.js');\nexports.__asyncZipAll = require('./__methods/async-zip-all.js');\nexports.__batch = require('./__methods/batch.js');\nexports.__bisect = require('./__methods/bisect.js');\nexports.__call = require('./__methods/call.js');\nexports.__collate = require('./__methods/collate.js');\nexports.__compress = require('./__methods/compress.js');\nexports.__concat = require('./__methods/concat.js');\nexports.__consume = require('./__methods/consume.js');\nexports.__cycle = require('./__methods/cycle.js');\nexports.__cycleTimes = require('./__methods/cycle-times.js');\nexports.__deepEqual = require('./__methods/deep-equal.js');\nexports.__distinct = require('./__methods/distinct.js');\nexports.__drop = require('./__methods/drop.js');\nexports.__dropWhile = require('./__methods/drop-while.js');\nexports.__enumerate = require('./__methods/enumerate.js');\nexports.__equal = require('./__methods/equal.js');\nexports.__every = require('./__methods/every.js');\nexports.__filter = require('./__methods/filter.js');\nexports.__find = require('./__methods/find.js');\nexports.__findBest = require('./__methods/find-best.js');\nexports.__findBestOr = require('./__methods/find-best-or.js');\nexports.__findOr = require('./__methods/find-or.js');\nexports.__first = require('./__methods/first.js');\nexports.__firstOr = require('./__methods/first-or.js');\nexports.__flat = require('./__methods/flat.js');\nexports.__flatMap = require('./__methods/flat-map.js');\nexports.__forEach = require('./__methods/for-each.js');\nexports.__fork = require('./__methods/fork.js');\nexports.__forkerate = require('./__methods/forkerate.js');\nexports.__includes = require('./__methods/includes.js');\nexports.__includesAny = require('./__methods/includes-any.js');\nexports.__includesAnySeq = require('./__methods/includes-any-seq.js');\nexports.__includesSeq = require('./__methods/includes-seq.js');\nexports.__interleave = require('./__methods/interleave.js');\nexports.__interpose = require('./__methods/interpose.js');\nexports.__interposeSeq = require('./__methods/interpose-seq.js');\nexports.__isEmpty = require('./__methods/is-empty.js');\nexports.__isSorted = require('./__methods/is-sorted.js');\nexports.__join = require('./__methods/join.js');\nexports.__joinWith = require('./__methods/join-with.js');\nexports.__joinWithSeq = require('./__methods/join-with-seq.js');\nexports.__map = require('./__methods/map.js');\nexports.__objectEntries = require('./__methods/object-entries.js');\nexports.__objectKeys = require('./__methods/object-keys.js');\nexports.__objectValues = require('./__methods/object-values.js');\nexports.__peekerate = require('./__methods/peekerate.js');\nexports.__prepend = require('./__methods/prepend.js');\nexports.__range = require('./__methods/range.js');\nexports.__reduce = require('./__methods/reduce.js');\nexports.__repeat = require('./__methods/repeat.js');\nexports.__repeatTimes = require('./__methods/repeat-times.js');\nexports.__reverse = require('./__methods/reverse.js');\nexports.__roundRobin = require('./__methods/round-robin.js');\nexports.__size = require('./__methods/size.js');\nexports.__slice = require('./__methods/slice.js');\nexports.__some = require('./__methods/some.js');\nexports.__split = require('./__methods/split.js');\nexports.__splitGroups = require('./__methods/split-groups.js');\nexports.__splitOn = require('./__methods/split-on.js');\nexports.__splitOnAny = require('./__methods/split-on-any.js');\nexports.__splitOnAnySeq = require('./__methods/split-on-any-seq.js');\nexports.__splitOnSeq = require('./__methods/split-on-seq.js');\nexports.__splitWhen = require('./__methods/split-when.js');\nexports.__spliterate = require('./__methods/spliterate.js');\nexports.__spliterateGrouped = require('./__methods/spliterate-grouped.js');\nexports.__startsWith = require('./__methods/starts-with.js');\nexports.__startsWithAny = require('./__methods/starts-with-any.js');\nexports.__startsWithAnySeq = require('./__methods/starts-with-any-seq.js');\nexports.__startsWithSeq = require('./__methods/starts-with-seq.js');\nexports.__str = require('./__methods/str.js');\nexports.__take = require('./__methods/take.js');\nexports.__takeLast = require('./__methods/take-last.js');\nexports.__takeLastOr = require('./__methods/take-last-or.js');\nexports.__takeSorted = require('./__methods/take-sorted.js');\nexports.__takeWhile = require('./__methods/take-while.js');\nexports.__tap = require('./__methods/tap.js');\nexports.__toArray = require('./__methods/to-array.js');\nexports.__toObject = require('./__methods/to-object.js');\nexports.__window = require('./__methods/window.js');\nexports.__windowAhead = require('./__methods/window-ahead.js');\nexports.__windowBehind = require('./__methods/window-behind.js');\nexports.__wrapEntries = require('./__methods/wrap-entries.js');\nexports.__wrapKeys = require('./__methods/wrap-keys.js');\nexports.__wrapValues = require('./__methods/wrap-values.js');\nexports.__zip = require('./__methods/zip.js');\nexports.__zipAll = require('./__methods/zip-all.js');\nexports.append = require('./methods/append.js');\nexports.apply = require('./methods/apply.js');\nexports.arrayFirst = require('./methods/array-first.js');\nexports.arrayFirstOr = require('./methods/array-first-or.js');\nexports.arrayFrom = require('./methods/array-from.js');\nexports.arrayFromAsync = require('./methods/array-from-async.js');\nexports.arrayLast = require('./methods/array-last.js');\nexports.arrayLastOr = require('./methods/array-last-or.js');\nexports.arrayReverse = require('./methods/array-reverse.js');\nexports.batch = require('./methods/batch.js');\nexports.bisect = require('./methods/bisect.js');\nexports.call = require('./methods/call.js');\nexports.collate = require('./methods/collate.js');\nexports.compose = require('./methods/compose.js');\nexports.compress = require('./methods/compress.js');\nexports.concat = require('./methods/concat.js');\nexports.consume = require('./methods/consume.js');\nexports.cycle = require('./methods/cycle.js');\nexports.cycleTimes = require('./methods/cycle-times.js');\nexports.deepEqual = require('./methods/deep-equal.js');\nexports.distinct = require('./methods/distinct.js');\nexports.drop = require('./methods/drop.js');\nexports.dropWhile = require('./methods/drop-while.js');\nexports.enumerate = require('./methods/enumerate.js');\nexports.equal = require('./methods/equal.js');\nexports.every = require('./methods/every.js');\nexports.execPipe = require('./methods/exec-pipe.js');\nexports.filter = require('./methods/filter.js');\nexports.find = require('./methods/find.js');\nexports.findBest = require('./methods/find-best.js');\nexports.findBestOr = require('./methods/find-best-or.js');\nexports.findOr = require('./methods/find-or.js');\nexports.first = require('./methods/first.js');\nexports.firstHighest = require('./methods/first-highest.js');\nexports.firstLowest = require('./methods/first-lowest.js');\nexports.firstOr = require('./methods/first-or.js');\nexports.flat = require('./methods/flat.js');\nexports.flatMap = require('./methods/flat-map.js');\nexports.forEach = require('./methods/for-each.js');\nexports.fork = require('./methods/fork.js');\nexports.forkerate = require('./methods/forkerate.js');\nexports.getSize = require('./methods/get-size.js');\nexports.includes = require('./methods/includes.js');\nexports.includesAny = require('./methods/includes-any.js');\nexports.includesAnySeq = require('./methods/includes-any-seq.js');\nexports.includesSeq = require('./methods/includes-seq.js');\nexports.interleave = require('./methods/interleave.js');\nexports.interpose = require('./methods/interpose.js');\nexports.interposeSeq = require('./methods/interpose-seq.js');\nexports.isArray = require('./methods/is-array.js');\nexports.isAsyncIterable = require('./methods/is-async-iterable.js');\nexports.isAsyncLoopable = require('./methods/is-async-loopable.js');\nexports.isAsyncWrappable = require('./methods/is-async-wrappable.js');\nexports.isEmpty = require('./methods/is-empty.js');\nexports.isIterable = require('./methods/is-iterable.js');\nexports.isLoopable = require('./methods/is-loopable.js');\nexports.isNil = require('./methods/is-nil.js');\nexports.isNull = require('./methods/is-null.js');\nexports.isObject = require('./methods/is-object.js');\nexports.isSorted = require('./methods/is-sorted.js');\nexports.isString = require('./methods/is-string.js');\nexports.isUndefined = require('./methods/is-undefined.js');\nexports.isWrappable = require('./methods/is-wrappable.js');\nexports.join = require('./methods/join.js');\nexports.joinWith = require('./methods/join-with.js');\nexports.joinWithSeq = require('./methods/join-with-seq.js');\nexports.lastHighest = require('./methods/last-highest.js');\nexports.lastLowest = require('./methods/last-lowest.js');\nexports.map = require('./methods/map.js');\nexports.notArray = require('./methods/not-array.js');\nexports.notAsyncIterable = require('./methods/not-async-iterable.js');\nexports.notAsyncLoopable = require('./methods/not-async-loopable.js');\nexports.notAsyncWrappable = require('./methods/not-async-wrappable.js');\nexports.notIterable = require('./methods/not-iterable.js');\nexports.notLoopable = require('./methods/not-loopable.js');\nexports.notNil = require('./methods/not-nil.js');\nexports.notNull = require('./methods/not-null.js');\nexports.notObject = require('./methods/not-object.js');\nexports.notString = require('./methods/not-string.js');\nexports.notUndefined = require('./methods/not-undefined.js');\nexports.notWrappable = require('./methods/not-wrappable.js');\nexports.objectEntries = require('./methods/object-entries.js');\nexports.objectFrom = require('./methods/object-from.js');\nexports.objectFromAsync = require('./methods/object-from-async.js');\nexports.objectKeys = require('./methods/object-keys.js');\nexports.objectValues = require('./methods/object-values.js');\nexports.peekerate = require('./methods/peekerate.js');\nexports.pipe = require('./methods/pipe.js');\nexports.prepend = require('./methods/prepend.js');\nexports.range = require('./methods/range.js');\nexports.reduce = require('./methods/reduce.js');\nexports.repeat = require('./methods/repeat.js');\nexports.repeatTimes = require('./methods/repeat-times.js');\nexports.reverse = require('./methods/reverse.js');\nexports.roundRobin = require('./methods/round-robin.js');\nexports.size = require('./methods/size.js');\nexports.slice = require('./methods/slice.js');\nexports.some = require('./methods/some.js');\nexports.split = require('./methods/split.js');\nexports.splitGroups = require('./methods/split-groups.js');\nexports.splitOn = require('./methods/split-on.js');\nexports.splitOnAny = require('./methods/split-on-any.js');\nexports.splitOnAnySeq = require('./methods/split-on-any-seq.js');\nexports.splitOnSeq = require('./methods/split-on-seq.js');\nexports.splitWhen = require('./methods/split-when.js');\nexports.spliterate = require('./methods/spliterate.js');\nexports.spliterateGrouped = require('./methods/spliterate-grouped.js');\nexports.startsWith = require('./methods/starts-with.js');\nexports.startsWithAny = require('./methods/starts-with-any.js');\nexports.startsWithAnySeq = require('./methods/starts-with-any-seq.js');\nexports.startsWithSeq = require('./methods/starts-with-seq.js');\nexports.str = require('./methods/str.js');\nexports.stringFrom = require('./methods/string-from.js');\nexports.stringFromAsync = require('./methods/string-from-async.js');\nexports.take = require('./methods/take.js');\nexports.takeLast = require('./methods/take-last.js');\nexports.takeLastOr = require('./methods/take-last-or.js');\nexports.takeSorted = require('./methods/take-sorted.js');\nexports.takeWhile = require('./methods/take-while.js');\nexports.tap = require('./methods/tap.js');\nexports.toArray = require('./methods/to-array.js');\nexports.toObject = require('./methods/to-object.js');\nexports.when = require('./methods/when.js');\nexports.window = require('./methods/window.js');\nexports.windowAhead = require('./methods/window-ahead.js');\nexports.windowBehind = require('./methods/window-behind.js');\nexports.wrap = require('./methods/wrap.js');\nexports.wrapEntries = require('./methods/wrap-entries.js');\nexports.wrapKeys = require('./methods/wrap-keys.js');\nexports.wrapValues = require('./methods/wrap-values.js');\nexports.zip = require('./methods/zip.js');\nexports.zipAll = require('./methods/zip-all.js');\nexports.asyncAppend = require('./methods/async-append.js');\nexports.asyncBatch = require('./methods/async-batch.js');\nexports.asyncBisect = require('./methods/async-bisect.js');\nexports.asyncBuffer = require('./methods/async-buffer.js');\nexports.asyncCollate = require('./methods/async-collate.js');\nexports.asyncCompress = require('./methods/async-compress.js');\nexports.asyncConcat = require('./methods/async-concat.js');\nexports.asyncConsume = require('./methods/async-consume.js');\nexports.asyncCycle = require('./methods/async-cycle.js');\nexports.asyncCycleTimes = require('./methods/async-cycle-times.js');\nexports.asyncDeepEqual = require('./methods/async-deep-equal.js');\nexports.asyncDistinct = require('./methods/async-distinct.js');\nexports.asyncDrop = require('./methods/async-drop.js');\nexports.asyncDropWhile = require('./methods/async-drop-while.js');\nexports.asyncEnumerate = require('./methods/async-enumerate.js');\nexports.asyncEqual = require('./methods/async-equal.js');\nexports.asyncEvery = require('./methods/async-every.js');\nexports.asyncFilter = require('./methods/async-filter.js');\nexports.asyncFind = require('./methods/async-find.js');\nexports.asyncFindBest = require('./methods/async-find-best.js');\nexports.asyncFindBestOr = require('./methods/async-find-best-or.js');\nexports.asyncFindOr = require('./methods/async-find-or.js');\nexports.asyncFirst = require('./methods/async-first.js');\nexports.asyncFirstOr = require('./methods/async-first-or.js');\nexports.asyncFlat = require('./methods/async-flat.js');\nexports.asyncFlatMap = require('./methods/async-flat-map.js');\nexports.asyncForEach = require('./methods/async-for-each.js');\nexports.asyncFork = require('./methods/async-fork.js');\nexports.asyncForkerate = require('./methods/async-forkerate.js');\nexports.asyncIncludes = require('./methods/async-includes.js');\nexports.asyncIncludesAny = require('./methods/async-includes-any.js');\nexports.asyncIncludesAnySeq = require('./methods/async-includes-any-seq.js');\nexports.asyncIncludesSeq = require('./methods/async-includes-seq.js');\nexports.asyncInterleave = require('./methods/async-interleave.js');\nexports.asyncInterleaveReady = require('./methods/async-interleave-ready.js');\nexports.asyncInterpose = require('./methods/async-interpose.js');\nexports.asyncInterposeSeq = require('./methods/async-interpose-seq.js');\nexports.asyncIsEmpty = require('./methods/async-is-empty.js');\nexports.asyncIsSorted = require('./methods/async-is-sorted.js');\nexports.asyncJoin = require('./methods/async-join.js');\nexports.asyncJoinWith = require('./methods/async-join-with.js');\nexports.asyncJoinWithSeq = require('./methods/async-join-with-seq.js');\nexports.asyncMap = require('./methods/async-map.js');\nexports.asyncPeekerate = require('./methods/async-peekerate.js');\nexports.asyncPrepend = require('./methods/async-prepend.js');\nexports.asyncReduce = require('./methods/async-reduce.js');\nexports.asyncReverse = require('./methods/async-reverse.js');\nexports.asyncRoundRobin = require('./methods/async-round-robin.js');\nexports.asyncSize = require('./methods/async-size.js');\nexports.asyncSlice = require('./methods/async-slice.js');\nexports.asyncSome = require('./methods/async-some.js');\nexports.asyncSplit = require('./methods/async-split.js');\nexports.asyncSplitGroups = require('./methods/async-split-groups.js');\nexports.asyncSplitOn = require('./methods/async-split-on.js');\nexports.asyncSplitOnAny = require('./methods/async-split-on-any.js');\nexports.asyncSplitOnAnySeq = require('./methods/async-split-on-any-seq.js');\nexports.asyncSplitOnSeq = require('./methods/async-split-on-seq.js');\nexports.asyncSplitWhen = require('./methods/async-split-when.js');\nexports.asyncSpliterate = require('./methods/async-spliterate.js');\nexports.asyncSpliterateGrouped = require('./methods/async-spliterate-grouped.js');\nexports.asyncStartsWith = require('./methods/async-starts-with.js');\nexports.asyncStartsWithAny = require('./methods/async-starts-with-any.js');\nexports.asyncStartsWithAnySeq = require('./methods/async-starts-with-any-seq.js');\nexports.asyncStartsWithSeq = require('./methods/async-starts-with-seq.js');\nexports.asyncStr = require('./methods/async-str.js');\nexports.asyncTake = require('./methods/async-take.js');\nexports.asyncTakeLast = require('./methods/async-take-last.js');\nexports.asyncTakeLastOr = require('./methods/async-take-last-or.js');\nexports.asyncTakeSorted = require('./methods/async-take-sorted.js');\nexports.asyncTakeWhile = require('./methods/async-take-while.js');\nexports.asyncTap = require('./methods/async-tap.js');\nexports.asyncThrottle = require('./methods/async-throttle.js');\nexports.asyncToArray = require('./methods/async-to-array.js');\nexports.asyncToObject = require('./methods/async-to-object.js');\nexports.asyncWindow = require('./methods/async-window.js');\nexports.asyncWindowAhead = require('./methods/async-window-ahead.js');\nexports.asyncWindowBehind = require('./methods/async-window-behind.js');\nexports.asyncWrap = require('./methods/async-wrap.js');\nexports.asyncZip = require('./methods/async-zip.js');\nexports.asyncZipAll = require('./methods/async-zip-all.js');","var _require = require('./iterable.js'),\n    ensureIterable = _require.ensureIterable;\n\nvar _require2 = require('../impls/$to-array/to-array.js'),\n    __toArray = _require2.__toArray;\n\nvar _require3 = require('../impls/$map/map.js'),\n    __map = _require3.__map;\n\nfunction seqsToArray(values) {\n  return __toArray(__map(values, function (value) {\n    return __toArray(ensureIterable(value));\n  }), function (arr) {\n    return arr.length > 0;\n  });\n}\n\nexports.seqsToArray = seqsToArray;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _require = require('./async-iterable.js'),\n    asyncEnsureIterable = _require.asyncEnsureIterable;\n\nvar _require2 = require('../impls/$to-array/async-to-array.js'),\n    __asyncToArray = _require2.__asyncToArray;\n\nvar _require3 = require('../impls/$map/async-map.js'),\n    __asyncMap = _require3.__asyncMap;\n\nfunction asyncSeqsToArray(_x) {\n  return _asyncSeqsToArray.apply(this, arguments);\n}\n\nfunction _asyncSeqsToArray() {\n  _asyncSeqsToArray = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(values) {\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            _context.next = 2;\n            return __asyncToArray(__asyncMap(values, function (value) {\n              return __asyncToArray(asyncEnsureIterable(value));\n            }), function (arr) {\n              return arr.length > 0;\n            });\n\n          case 2:\n            return _context.abrupt(\"return\", _context.sent);\n\n          case 3:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncSeqsToArray.apply(this, arguments);\n}\n\nexports.asyncSeqsToArray = asyncSeqsToArray;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar _inherits = require(\"@babel/runtime/helpers/inherits\");\n\nvar _possibleConstructorReturn = require(\"@babel/runtime/helpers/possibleConstructorReturn\");\n\nvar _getPrototypeOf = require(\"@babel/runtime/helpers/getPrototypeOf\");\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _asyncGeneratorDelegate = require(\"@babel/runtime/helpers/asyncGeneratorDelegate\");\n\nvar _require = require('./iterable-iterator.js'),\n    IterableIterator = _require.IterableIterator;\n\nvar _require2 = require('./async-parts-iterator.js'),\n    AsyncPartsIterator = _require2.AsyncPartsIterator;\n\nvar AsyncBisector = /*#__PURE__*/function (_IterableIterator) {\n  _inherits(AsyncBisector, _IterableIterator);\n\n  var _super = _createSuper(AsyncBisector);\n\n  function AsyncBisector(source, strategy, options) {\n    var _this;\n\n    _classCallCheck(this, AsyncBisector);\n\n    _this = _super.call(this);\n    _this.source = source;\n    _this.strategy = strategy;\n    _this.options = options;\n    _this.partsIterator = null;\n    _this.firstPart = null;\n    _this.secondPart = null;\n    _this.currentIdx = 0;\n    return _this;\n  }\n\n  _createClass(AsyncBisector, [{\n    key: \"setupFirst\",\n    value: function () {\n      var _setupFirst = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {\n        var source, strategy, options, step;\n        return _regeneratorRuntime.wrap(function _callee$(_context) {\n          while (1) {\n            switch (_context.prev = _context.next) {\n              case 0:\n                source = this.source, strategy = this.strategy, options = this.options;\n                this.partsIterator = this.partsIterator || new AsyncPartsIterator(source, strategy, options);\n\n                if (this.firstPart) {\n                  _context.next = 7;\n                  break;\n                }\n\n                _context.next = 5;\n                return this.partsIterator.next();\n\n              case 5:\n                step = _context.sent;\n                this.firstPart = step.done ? [] : step.value;\n\n              case 7:\n              case \"end\":\n                return _context.stop();\n            }\n          }\n        }, _callee, this);\n      }));\n\n      function setupFirst() {\n        return _setupFirst.apply(this, arguments);\n      }\n\n      return setupFirst;\n    }()\n  }, {\n    key: \"next\",\n    value: function next() {\n      var self = this;\n\n      switch (this.currentIdx++) {\n        case 0:\n          return {\n            value: _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {\n              return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n                while (1) {\n                  switch (_context2.prev = _context2.next) {\n                    case 0:\n                      _context2.next = 2;\n                      return _awaitAsyncGenerator(self.setupFirst());\n\n                    case 2:\n                      return _context2.delegateYield(_asyncGeneratorDelegate(_asyncIterator(self.firstPart), _awaitAsyncGenerator), \"t0\", 3);\n\n                    case 3:\n                    case \"end\":\n                      return _context2.stop();\n                  }\n                }\n              }, _callee2);\n            }))(),\n            done: false\n          };\n\n        case 1:\n          return {\n            value: _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {\n              var step;\n              return _regeneratorRuntime.wrap(function _callee3$(_context3) {\n                while (1) {\n                  switch (_context3.prev = _context3.next) {\n                    case 0:\n                      _context3.next = 2;\n                      return _awaitAsyncGenerator(self.setupFirst());\n\n                    case 2:\n                      _context3.next = 4;\n                      return _awaitAsyncGenerator(self.partsIterator.next());\n\n                    case 4:\n                      step = _context3.sent;\n                      self.secondPart = step.done ? [] : step.value;\n                      return _context3.delegateYield(_asyncGeneratorDelegate(_asyncIterator(self.secondPart), _awaitAsyncGenerator), \"t0\", 7);\n\n                    case 7:\n                    case \"end\":\n                      return _context3.stop();\n                  }\n                }\n              }, _callee3);\n            }))(),\n            done: false\n          };\n\n        default:\n          return {\n            value: undefined,\n            done: true\n          };\n      }\n    }\n  }, {\n    key: \"return\",\n    value: function _return() {\n      if (this.currentIdx === 1) {\n        throw new Error('You must take both parts of a bisector or neither.');\n      }\n\n      return {\n        value: undefined,\n        done: true\n      };\n    }\n  }]);\n\n  return AsyncBisector;\n}(IterableIterator);\n\nexports.AsyncBisector = AsyncBisector;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar _inherits = require(\"@babel/runtime/helpers/inherits\");\n\nvar _possibleConstructorReturn = require(\"@babel/runtime/helpers/possibleConstructorReturn\");\n\nvar _getPrototypeOf = require(\"@babel/runtime/helpers/getPrototypeOf\");\n\nvar _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nvar _require = require('./async-iterable-iterator.js'),\n    AsyncIterableIterator = _require.AsyncIterableIterator;\n\nvar _require2 = require('./async-iterable.js'),\n    asyncCallReturn = _require2.asyncCallReturn;\n\nvar QueueItem = function QueueItem(step) {\n  _classCallCheck(this, QueueItem);\n\n  this.step = step;\n  this.next = null;\n};\n\nvar AsyncFork = /*#__PURE__*/function (_AsyncIterableIterato) {\n  _inherits(AsyncFork, _AsyncIterableIterato);\n\n  var _super = _createSuper(AsyncFork);\n\n  function AsyncFork(head, exchange) {\n    var _this;\n\n    _classCallCheck(this, AsyncFork);\n\n    _this = _super.call(this);\n    _this.head = head;\n    _this.done = false;\n    _this.exchange = exchange;\n    return _this;\n  }\n\n  _createClass(AsyncFork, [{\n    key: \"next\",\n    value: function () {\n      var _next = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {\n        var done, exchange, head, _head, step;\n\n        return _regeneratorRuntime.wrap(function _callee$(_context) {\n          while (1) {\n            switch (_context.prev = _context.next) {\n              case 0:\n                done = this.done, exchange = this.exchange;\n\n                if (!done) {\n                  _context.next = 5;\n                  break;\n                }\n\n                return _context.abrupt(\"return\", {\n                  value: undefined,\n                  done: done\n                });\n\n              case 5:\n                head = this.head;\n\n                if (head.next) {\n                  _context.next = 9;\n                  break;\n                }\n\n                _context.next = 9;\n                return exchange.fetch();\n\n              case 9:\n                head = head.next;\n                _head = head, step = _head.step;\n                this.done = step.done;\n                this.head = head;\n                return _context.abrupt(\"return\", step);\n\n              case 14:\n              case \"end\":\n                return _context.stop();\n            }\n          }\n        }, _callee, this);\n      }));\n\n      function next() {\n        return _next.apply(this, arguments);\n      }\n\n      return next;\n    }()\n  }, {\n    key: \"return\",\n    value: function () {\n      var _return2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {\n        var done, exchange;\n        return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n          while (1) {\n            switch (_context2.prev = _context2.next) {\n              case 0:\n                done = this.done, exchange = this.exchange;\n\n                if (done) {\n                  _context2.next = 4;\n                  break;\n                }\n\n                _context2.next = 4;\n                return exchange[\"return\"]();\n\n              case 4:\n                return _context2.abrupt(\"return\", {\n                  value: undefined,\n                  done: true\n                });\n\n              case 5:\n              case \"end\":\n                return _context2.stop();\n            }\n          }\n        }, _callee2, this);\n      }));\n\n      function _return() {\n        return _return2.apply(this, arguments);\n      }\n\n      return _return;\n    }()\n  }]);\n\n  return AsyncFork;\n}(AsyncIterableIterator);\n\nvar AsyncExchange = /*#__PURE__*/function () {\n  function AsyncExchange(iterator) {\n    _classCallCheck(this, AsyncExchange);\n\n    this.iterator = iterator;\n    this.tail = new QueueItem(null);\n    this.head = this.tail;\n    this.forks = 0;\n  }\n\n  _createClass(AsyncExchange, [{\n    key: \"fork\",\n    value: function fork() {\n      ++this.forks;\n      return new AsyncFork(this.tail, this);\n    }\n  }, {\n    key: \"advance\",\n    value: function advance() {\n      this.tail = this.tail.next;\n    }\n  }, {\n    key: \"fetch\",\n    value: function () {\n      var _fetch = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {\n        var step, newItem;\n        return _regeneratorRuntime.wrap(function _callee3$(_context3) {\n          while (1) {\n            switch (_context3.prev = _context3.next) {\n              case 0:\n                _context3.next = 2;\n                return this.iterator.next();\n\n              case 2:\n                step = _context3.sent;\n                newItem = new QueueItem(step);\n                this.head.next = this.head = newItem;\n\n              case 5:\n              case \"end\":\n                return _context3.stop();\n            }\n          }\n        }, _callee3, this);\n      }));\n\n      function fetch() {\n        return _fetch.apply(this, arguments);\n      }\n\n      return fetch;\n    }()\n  }, {\n    key: \"return\",\n    value: function () {\n      var _return3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {\n        return _regeneratorRuntime.wrap(function _callee4$(_context4) {\n          while (1) {\n            switch (_context4.prev = _context4.next) {\n              case 0:\n                --this.forks;\n\n                if (!(this.forks === 0)) {\n                  _context4.next = 4;\n                  break;\n                }\n\n                _context4.next = 4;\n                return asyncCallReturn(this.iterator);\n\n              case 4:\n                return _context4.abrupt(\"return\", {\n                  value: undefined,\n                  done: true\n                });\n\n              case 5:\n              case \"end\":\n                return _context4.stop();\n            }\n          }\n        }, _callee4, this);\n      }));\n\n      function _return() {\n        return _return3.apply(this, arguments);\n      }\n\n      return _return;\n    }()\n  }]);\n\n  return AsyncExchange;\n}();\n\nexports.AsyncExchange = AsyncExchange;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar _inherits = require(\"@babel/runtime/helpers/inherits\");\n\nvar _possibleConstructorReturn = require(\"@babel/runtime/helpers/possibleConstructorReturn\");\n\nvar _getPrototypeOf = require(\"@babel/runtime/helpers/getPrototypeOf\");\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nvar _require = require('./async-parts-iterator.js'),\n    AsyncPartsIterator = _require.AsyncPartsIterator,\n    AsyncPartIterator = _require.AsyncPartIterator;\n\nvar _require2 = require('./symbols.js'),\n    split = _require2.split;\n\nvar AsyncGroupsIterator = /*#__PURE__*/function (_AsyncPartsIterator) {\n  _inherits(AsyncGroupsIterator, _AsyncPartsIterator);\n\n  var _super = _createSuper(AsyncGroupsIterator);\n\n  function AsyncGroupsIterator() {\n    _classCallCheck(this, AsyncGroupsIterator);\n\n    return _super.apply(this, arguments);\n  }\n\n  _createClass(AsyncGroupsIterator, [{\n    key: \"next\",\n    value: function () {\n      var _next = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {\n        var spliterator, key;\n        return _regeneratorRuntime.wrap(function _callee$(_context) {\n          while (1) {\n            switch (_context.prev = _context.next) {\n              case 0:\n                if (this.initialized) {\n                  _context.next = 3;\n                  break;\n                }\n\n                _context.next = 3;\n                return this.init();\n\n              case 3:\n                spliterator = this.spliterator;\n\n                if (!(this.currentPart !== null)) {\n                  _context.next = 12;\n                  break;\n                }\n\n                if (!(spliterator.value !== split || spliterator.current === this.splitStep)) {\n                  _context.next = 12;\n                  break;\n                }\n\n                this.currentPart.inactive = true;\n\n              case 7:\n                if (!(!spliterator.done && spliterator.value !== split)) {\n                  _context.next = 12;\n                  break;\n                }\n\n                _context.next = 10;\n                return spliterator.advance();\n\n              case 10:\n                _context.next = 7;\n                break;\n\n              case 12:\n                if (!spliterator.done) {\n                  _context.next = 14;\n                  break;\n                }\n\n                return _context.abrupt(\"return\", {\n                  value: undefined,\n                  done: true\n                });\n\n              case 14:\n                _context.next = 16;\n                return spliterator.advance();\n\n              case 16:\n                if (!(spliterator.done || spliterator.value === split)) {\n                  _context.next = 18;\n                  break;\n                }\n\n                throw new Error('Unexpected empty group');\n\n              case 18:\n                key = spliterator.value;\n                _context.next = 21;\n                return spliterator.advance();\n\n              case 21:\n                this.splitStep = spliterator.current;\n                this.currentPart = new AsyncPartIterator(this);\n                return _context.abrupt(\"return\", {\n                  value: [key, this.currentPart],\n                  done: false\n                });\n\n              case 24:\n              case \"end\":\n                return _context.stop();\n            }\n          }\n        }, _callee, this);\n      }));\n\n      function next() {\n        return _next.apply(this, arguments);\n      }\n\n      return next;\n    }()\n  }]);\n\n  return AsyncGroupsIterator;\n}(AsyncPartsIterator);\n\nexports.AsyncGroupsIterator = AsyncGroupsIterator;","var _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar AsyncIterableIterator = /*#__PURE__*/function () {\n  function AsyncIterableIterator() {\n    _classCallCheck(this, AsyncIterableIterator);\n  }\n\n  _createClass(AsyncIterableIterator, [{\n    key: Symbol.asyncIterator,\n    value: function value() {\n      return this;\n    }\n  }]);\n\n  return AsyncIterableIterator;\n}();\n\nexports.AsyncIterableIterator = AsyncIterableIterator;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _defineProperty = require(\"@babel/runtime/helpers/defineProperty\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _require = require('../impls/is-async-iterable/is-async-iterable.js'),\n    isAsyncIterable = _require.isAsyncIterable;\n\nvar _require2 = require('../impls/is-async-loopable/is-async-loopable.js'),\n    isAsyncLoopable = _require2.isAsyncLoopable;\n\nvar _require3 = require('../impls/is-async-wrappable/is-async-wrappable.js'),\n    isAsyncWrappable = _require3.isAsyncWrappable;\n\nvar _require4 = require('./async-wrap.js'),\n    asyncWrap = _require4.asyncNullableWrap;\n\nvar _require5 = require('./iterable.js'),\n    BaseIterableIterator = _require5.BaseIterableIterator,\n    IterableIterator = _require5.IterableIterator;\n\nvar _require6 = require('./curry.js'),\n    variadicCurryWithValidation = _require6.variadicCurryWithValidation;\n\nvar _require7 = require('./symbols.js'),\n    __iterate = _require7.__iterate;\n\nexports.asyncWrap = asyncWrap;\nexports.asyncIsIterable = isAsyncIterable;\nexports.asyncIsLoopable = isAsyncLoopable;\nexports.asyncIsWrappable = isAsyncWrappable;\n\nfunction asyncCallReturn(_x) {\n  return _asyncCallReturn.apply(this, arguments);\n}\n\nfunction _asyncCallReturn() {\n  _asyncCallReturn = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(iterator) {\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            if (!('return' in iterator)) {\n              _context.next = 3;\n              break;\n            }\n\n            _context.next = 3;\n            return iterator[\"return\"]();\n\n          case 3:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncCallReturn.apply(this, arguments);\n}\n\nexports.asyncCallReturn = asyncCallReturn;\n\nfunction asyncEnsureIterable(value) {\n  if (!isAsyncWrappable(value)) {\n    if (typeof value.next === 'function') {\n      throw new TypeError('iter-tools received a value that looked like an iterator but was not async iterable. Get help fixing this: https://github.com/iter-tools/iter-tools/wiki/Making-iterators-iterable#async-iterators');\n    } else throw new TypeError('Expected an async iterable, sync iterable, null or undefined');\n  } else if (isAsyncIterable(value)) {\n    return value;\n  } else {\n    return asyncWrap(value);\n  }\n}\n\nexports.asyncEnsureIterable = asyncEnsureIterable;\n\nfunction AsyncIterableIterator() {\n  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n    args[_key] = arguments[_key];\n  }\n\n  BaseIterableIterator.apply(this, args);\n}\n\nexports.AsyncIterableIterator = AsyncIterableIterator;\nAsyncIterableIterator.prototype = Object.assign(Object.create(BaseIterableIterator.prototype), _defineProperty({\n  constructor: AsyncIterableIterator\n}, Symbol.asyncIterator, function () {\n  return this[__iterate]();\n}));\n\nfunction makeFunctionConfig(fn) {\n  var fnConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  var _fnConfig$validateArg = fnConfig.validateArgs,\n      validateArgs = _fnConfig$validateArg === void 0 ? function (_) {} : _fnConfig$validateArg,\n      _fnConfig$variadic = fnConfig.variadic,\n      variadic = _fnConfig$variadic === void 0 ? false : _fnConfig$variadic,\n      _fnConfig$reduces = fnConfig.reduces,\n      reduces = _fnConfig$reduces === void 0 ? false : _fnConfig$reduces,\n      _fnConfig$growRight = fnConfig.growRight,\n      growRight = _fnConfig$growRight === void 0 ? false : _fnConfig$growRight,\n      _fnConfig$minArgs = fnConfig.minArgs,\n      minArgs = _fnConfig$minArgs === void 0 ? fn.length - 1 : _fnConfig$minArgs,\n      _fnConfig$maxArgs = fnConfig.maxArgs,\n      maxArgs = _fnConfig$maxArgs === void 0 ? fn.length - 1 : _fnConfig$maxArgs,\n      _fnConfig$forceSync = fnConfig.forceSync,\n      forceSync = _fnConfig$forceSync === void 0 ? false : _fnConfig$forceSync,\n      _fnConfig$applyOnIter = fnConfig.applyOnIterableArgs,\n      applyOnIterableArgs = _fnConfig$applyOnIter === void 0 ? asyncEnsureIterable : _fnConfig$applyOnIter;\n  return {\n    fn: fn,\n    validateArgs: validateArgs,\n    variadic: variadic,\n    reduces: reduces,\n    growRight: growRight,\n    minArgs: minArgs,\n    maxArgs: maxArgs,\n    isIterable: isAsyncWrappable,\n    iterableType: 'asyncIterable',\n    applyOnIterableArgs: applyOnIterableArgs,\n    IterableClass: forceSync ? IterableIterator : AsyncIterableIterator\n  };\n}\n\nfunction asyncCache(_x2) {\n  return _asyncCache.apply(this, arguments);\n}\n\nfunction _asyncCache() {\n  _asyncCache = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(it) {\n    var arr, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, value;\n\n    return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n      while (1) {\n        switch (_context2.prev = _context2.next) {\n          case 0:\n            arr = [];\n            _iteratorNormalCompletion = true;\n            _didIteratorError = false;\n            _context2.prev = 3;\n            _iterator = _asyncIterator(it);\n\n          case 5:\n            _context2.next = 7;\n            return _iterator.next();\n\n          case 7:\n            _step = _context2.sent;\n            _iteratorNormalCompletion = _step.done;\n            _context2.next = 11;\n            return _step.value;\n\n          case 11:\n            _value = _context2.sent;\n\n            if (_iteratorNormalCompletion) {\n              _context2.next = 18;\n              break;\n            }\n\n            value = _value;\n            arr.push(value);\n\n          case 15:\n            _iteratorNormalCompletion = true;\n            _context2.next = 5;\n            break;\n\n          case 18:\n            _context2.next = 24;\n            break;\n\n          case 20:\n            _context2.prev = 20;\n            _context2.t0 = _context2[\"catch\"](3);\n            _didIteratorError = true;\n            _iteratorError = _context2.t0;\n\n          case 24:\n            _context2.prev = 24;\n            _context2.prev = 25;\n\n            if (!(!_iteratorNormalCompletion && _iterator[\"return\"] != null)) {\n              _context2.next = 29;\n              break;\n            }\n\n            _context2.next = 29;\n            return _iterator[\"return\"]();\n\n          case 29:\n            _context2.prev = 29;\n\n            if (!_didIteratorError) {\n              _context2.next = 32;\n              break;\n            }\n\n            throw _iteratorError;\n\n          case 32:\n            return _context2.finish(29);\n\n          case 33:\n            return _context2.finish(24);\n\n          case 34:\n            return _context2.abrupt(\"return\", asyncWrapWithIterableIterator(asyncWrap)(arr));\n\n          case 35:\n          case \"end\":\n            return _context2.stop();\n        }\n      }\n    }, _callee2, null, [[3, 20, 24, 34], [25,, 29, 33]]);\n  }));\n  return _asyncCache.apply(this, arguments);\n}\n\nexports.asyncCache = asyncCache;\n\nfunction asyncWrapWithIterableIterator(fn) {\n  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n      _ref$validateArgs = _ref.validateArgs,\n      validateArgs = _ref$validateArgs === void 0 ? function (_) {\n    return _;\n  } : _ref$validateArgs;\n\n  return function () {\n    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      args[_key2] = arguments[_key2];\n    }\n\n    validateArgs(args);\n    return new AsyncIterableIterator(fn, args);\n  };\n}\n\nexports.asyncWrapWithIterableIterator = asyncWrapWithIterableIterator;\n\nvar asyncIterableCurry = function asyncIterableCurry(fn, config) {\n  return variadicCurryWithValidation(makeFunctionConfig(fn, config));\n};\n\nexports.asyncIterableCurry = asyncIterableCurry;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(map);\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction map(iterable, cb) {\n  var _iterator, _step, value;\n\n  return _regeneratorRuntime.wrap(function map$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          _iterator = _createForOfIteratorHelper(iterable);\n          _context.prev = 1;\n\n          _iterator.s();\n\n        case 3:\n          if ((_step = _iterator.n()).done) {\n            _context.next = 9;\n            break;\n          }\n\n          value = _step.value;\n          _context.next = 7;\n          return cb(value);\n\n        case 7:\n          _context.next = 3;\n          break;\n\n        case 9:\n          _context.next = 14;\n          break;\n\n        case 11:\n          _context.prev = 11;\n          _context.t0 = _context[\"catch\"](1);\n\n          _iterator.e(_context.t0);\n\n        case 14:\n          _context.prev = 14;\n\n          _iterator.f();\n\n          return _context.finish(14);\n\n        case 17:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked, null, [[1, 11, 14, 17]]);\n}\n\nfunction asyncParallelEach(iterable, cb) {\n  return Promise.all(map(iterable, cb));\n}\n\nexports.asyncParallelEach = asyncParallelEach;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar _inherits = require(\"@babel/runtime/helpers/inherits\");\n\nvar _possibleConstructorReturn = require(\"@babel/runtime/helpers/possibleConstructorReturn\");\n\nvar _getPrototypeOf = require(\"@babel/runtime/helpers/getPrototypeOf\");\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nvar _require = require('./symbols.js'),\n    split = _require.split;\n\nvar _require2 = require('./async-iterable-iterator.js'),\n    AsyncIterableIterator = _require2.AsyncIterableIterator;\n\nvar _require3 = require('./async-peekerator.js'),\n    AsyncPeekerator = _require3.AsyncPeekerator;\n\nvar AsyncPartIterator = /*#__PURE__*/function (_AsyncIterableIterato) {\n  _inherits(AsyncPartIterator, _AsyncIterableIterato);\n\n  var _super = _createSuper(AsyncPartIterator);\n\n  function AsyncPartIterator(partsIterator) {\n    var _this;\n\n    _classCallCheck(this, AsyncPartIterator);\n\n    _this = _super.call(this);\n    _this.partsIterator = partsIterator;\n    _this.inactive = false;\n    _this.done = false;\n    return _this;\n  }\n\n  _createClass(AsyncPartIterator, [{\n    key: \"assertActive\",\n    value: function assertActive() {\n      if (this.inactive && !this.done) {\n        throw new Error('Cannot take from this split part. It is no longer the active part.');\n      }\n    }\n  }, {\n    key: \"next\",\n    value: function () {\n      var _next = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {\n        var spliterator, current;\n        return _regeneratorRuntime.wrap(function _callee$(_context) {\n          while (1) {\n            switch (_context.prev = _context.next) {\n              case 0:\n                spliterator = this.partsIterator.spliterator;\n                current = spliterator.current;\n                this.assertActive();\n\n                if (!(this.done || current.done || current.value === split)) {\n                  _context.next = 10;\n                  break;\n                }\n\n                this.done = true;\n                _context.next = 7;\n                return this.partsIterator.maybeReturnSource();\n\n              case 7:\n                return _context.abrupt(\"return\", {\n                  value: undefined,\n                  done: true\n                });\n\n              case 10:\n                _context.next = 12;\n                return spliterator.advance();\n\n              case 12:\n                return _context.abrupt(\"return\", current);\n\n              case 13:\n              case \"end\":\n                return _context.stop();\n            }\n          }\n        }, _callee, this);\n      }));\n\n      function next() {\n        return _next.apply(this, arguments);\n      }\n\n      return next;\n    }()\n  }, {\n    key: \"return\",\n    value: function () {\n      var _return2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {\n        return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n          while (1) {\n            switch (_context2.prev = _context2.next) {\n              case 0:\n                this.done = true;\n                _context2.next = 3;\n                return this.partsIterator.maybeReturnSource();\n\n              case 3:\n                return _context2.abrupt(\"return\", {\n                  value: undefined,\n                  done: true\n                });\n\n              case 4:\n              case \"end\":\n                return _context2.stop();\n            }\n          }\n        }, _callee2, this);\n      }));\n\n      function _return() {\n        return _return2.apply(this, arguments);\n      }\n\n      return _return;\n    }()\n  }, {\n    key: \"throw\",\n    value: function () {\n      var _throw2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {\n        return _regeneratorRuntime.wrap(function _callee3$(_context3) {\n          while (1) {\n            switch (_context3.prev = _context3.next) {\n              case 0:\n                _context3.next = 2;\n                return this[\"return\"]();\n\n              case 2:\n                return _context3.abrupt(\"return\", _context3.sent);\n\n              case 3:\n              case \"end\":\n                return _context3.stop();\n            }\n          }\n        }, _callee3, this);\n      }));\n\n      function _throw() {\n        return _throw2.apply(this, arguments);\n      }\n\n      return _throw;\n    }()\n  }]);\n\n  return AsyncPartIterator;\n}(AsyncIterableIterator);\n\nexports.AsyncPartIterator = AsyncPartIterator;\n\nvar AsyncPartsIterator = /*#__PURE__*/function (_AsyncIterableIterato2) {\n  _inherits(AsyncPartsIterator, _AsyncIterableIterato2);\n\n  var _super2 = _createSuper(AsyncPartsIterator);\n\n  function AsyncPartsIterator(source, strategy, options) {\n    var _this2;\n\n    _classCallCheck(this, AsyncPartsIterator);\n\n    _this2 = _super2.call(this);\n    _this2.source = source;\n    _this2.strategy = strategy;\n    _this2.options = options;\n    _this2.initialized = false;\n    _this2.returned = false;\n    _this2.spliterator = null;\n    _this2.currentPart = null;\n    _this2.splitStep = null;\n    return _this2;\n  }\n\n  _createClass(AsyncPartsIterator, [{\n    key: \"init\",\n    value: function () {\n      var _init = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {\n        var source, strategy, options;\n        return _regeneratorRuntime.wrap(function _callee4$(_context4) {\n          while (1) {\n            switch (_context4.prev = _context4.next) {\n              case 0:\n                this.initialized = true;\n                source = this.source, strategy = this.strategy, options = this.options;\n                _context4.next = 4;\n                return AsyncPeekerator.from(strategy(split, options, source));\n\n              case 4:\n                this.spliterator = _context4.sent;\n\n              case 5:\n              case \"end\":\n                return _context4.stop();\n            }\n          }\n        }, _callee4, this);\n      }));\n\n      function init() {\n        return _init.apply(this, arguments);\n      }\n\n      return init;\n    }()\n  }, {\n    key: \"maybeReturnSource\",\n    value: function () {\n      var _maybeReturnSource = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {\n        return _regeneratorRuntime.wrap(function _callee5$(_context5) {\n          while (1) {\n            switch (_context5.prev = _context5.next) {\n              case 0:\n                if (!(this.spliterator && this.returned && this.currentPart.done)) {\n                  _context5.next = 3;\n                  break;\n                }\n\n                _context5.next = 3;\n                return this.spliterator[\"return\"]();\n\n              case 3:\n              case \"end\":\n                return _context5.stop();\n            }\n          }\n        }, _callee5, this);\n      }));\n\n      function maybeReturnSource() {\n        return _maybeReturnSource.apply(this, arguments);\n      }\n\n      return maybeReturnSource;\n    }()\n  }, {\n    key: \"next\",\n    value: function () {\n      var _next2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {\n        var spliterator;\n        return _regeneratorRuntime.wrap(function _callee6$(_context6) {\n          while (1) {\n            switch (_context6.prev = _context6.next) {\n              case 0:\n                if (this.initialized) {\n                  _context6.next = 3;\n                  break;\n                }\n\n                _context6.next = 3;\n                return this.init();\n\n              case 3:\n                spliterator = this.spliterator;\n\n                if (!spliterator.done) {\n                  _context6.next = 6;\n                  break;\n                }\n\n                return _context6.abrupt(\"return\", {\n                  value: undefined,\n                  done: true\n                });\n\n              case 6:\n                if (!(this.currentPart !== null)) {\n                  _context6.next = 16;\n                  break;\n                }\n\n                if (!(spliterator.value !== split || spliterator.current === this.splitStep)) {\n                  _context6.next = 14;\n                  break;\n                }\n\n                this.currentPart.inactive = true;\n\n              case 9:\n                if (!(!spliterator.done && spliterator.value !== split)) {\n                  _context6.next = 14;\n                  break;\n                }\n\n                _context6.next = 12;\n                return spliterator.advance();\n\n              case 12:\n                _context6.next = 9;\n                break;\n\n              case 14:\n                _context6.next = 16;\n                return spliterator.advance();\n\n              case 16:\n                this.splitStep = spliterator.current;\n                this.currentPart = new AsyncPartIterator(this);\n                return _context6.abrupt(\"return\", {\n                  value: this.currentPart,\n                  done: false\n                });\n\n              case 19:\n              case \"end\":\n                return _context6.stop();\n            }\n          }\n        }, _callee6, this);\n      }));\n\n      function next() {\n        return _next2.apply(this, arguments);\n      }\n\n      return next;\n    }()\n  }, {\n    key: \"return\",\n    value: function () {\n      var _return3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(value) {\n        return _regeneratorRuntime.wrap(function _callee7$(_context7) {\n          while (1) {\n            switch (_context7.prev = _context7.next) {\n              case 0:\n                this.returned = true;\n                _context7.next = 3;\n                return this.maybeReturnSource();\n\n              case 3:\n                return _context7.abrupt(\"return\", {\n                  value: value,\n                  done: true\n                });\n\n              case 4:\n              case \"end\":\n                return _context7.stop();\n            }\n          }\n        }, _callee7, this);\n      }));\n\n      function _return(_x) {\n        return _return3.apply(this, arguments);\n      }\n\n      return _return;\n    }()\n  }, {\n    key: \"throw\",\n    value: function () {\n      var _throw3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {\n        return _regeneratorRuntime.wrap(function _callee8$(_context8) {\n          while (1) {\n            switch (_context8.prev = _context8.next) {\n              case 0:\n                _context8.next = 2;\n                return this[\"return\"]();\n\n              case 2:\n                return _context8.abrupt(\"return\", _context8.sent);\n\n              case 3:\n              case \"end\":\n                return _context8.stop();\n            }\n          }\n        }, _callee8, this);\n      }));\n\n      function _throw() {\n        return _throw3.apply(this, arguments);\n      }\n\n      return _throw;\n    }()\n  }]);\n\n  return AsyncPartsIterator;\n}(AsyncIterableIterator);\n\nexports.AsyncPartsIterator = AsyncPartsIterator;","var _construct = require(\"@babel/runtime/helpers/construct\");\n\nvar _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _asyncToGenerator = require(\"@babel/runtime/helpers/asyncToGenerator\");\n\nvar _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar _require = require('./async-iterable.js'),\n    asyncEnsureIterable = _require.asyncEnsureIterable,\n    asyncCallReturn = _require.asyncCallReturn;\n\nvar _ = Symbol[\"for\"]('_');\n\nvar AsyncPeekeratorIterator = /*#__PURE__*/function () {\n  function AsyncPeekeratorIterator(peekr) {\n    _classCallCheck(this, AsyncPeekeratorIterator);\n\n    this.peekr = peekr;\n  }\n\n  _createClass(AsyncPeekeratorIterator, [{\n    key: \"next\",\n    value: function () {\n      var _next = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {\n        var peekr, current;\n        return _regeneratorRuntime.wrap(function _callee$(_context) {\n          while (1) {\n            switch (_context.prev = _context.next) {\n              case 0:\n                peekr = this.peekr;\n                current = peekr.current;\n                _context.next = 4;\n                return peekr.advance();\n\n              case 4:\n                return _context.abrupt(\"return\", current);\n\n              case 5:\n              case \"end\":\n                return _context.stop();\n            }\n          }\n        }, _callee, this);\n      }));\n\n      function next() {\n        return _next.apply(this, arguments);\n      }\n\n      return next;\n    }()\n  }, {\n    key: \"return\",\n    value: function () {\n      var _return2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {\n        return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n          while (1) {\n            switch (_context2.prev = _context2.next) {\n              case 0:\n                _context2.next = 2;\n                return this.peekr[\"return\"]();\n\n              case 2:\n                return _context2.abrupt(\"return\", {\n                  value: undefined,\n                  done: true\n                });\n\n              case 3:\n              case \"end\":\n                return _context2.stop();\n            }\n          }\n        }, _callee2, this);\n      }));\n\n      function _return() {\n        return _return2.apply(this, arguments);\n      }\n\n      return _return;\n    }()\n  }, {\n    key: Symbol.asyncIterator,\n    value: function value() {\n      return this;\n    }\n  }]);\n\n  return AsyncPeekeratorIterator;\n}();\n\nvar AsyncPeekerator = /*#__PURE__*/function () {\n  _createClass(AsyncPeekerator, null, [{\n    key: \"from\",\n    value: function () {\n      var _from = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(iterable) {\n        var iterator,\n            first,\n            _len,\n            args,\n            _key,\n            _args3 = arguments;\n\n        return _regeneratorRuntime.wrap(function _callee3$(_context3) {\n          while (1) {\n            switch (_context3.prev = _context3.next) {\n              case 0:\n                iterator = asyncEnsureIterable(iterable)[Symbol.asyncIterator]();\n                _context3.next = 3;\n                return iterator.next();\n\n              case 3:\n                first = _context3.sent;\n\n                for (_len = _args3.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n                  args[_key - 1] = _args3[_key];\n                }\n\n                return _context3.abrupt(\"return\", _construct(this, [iterator, first].concat(args)));\n\n              case 6:\n              case \"end\":\n                return _context3.stop();\n            }\n          }\n        }, _callee3, this);\n      }));\n\n      function from(_x) {\n        return _from.apply(this, arguments);\n      }\n\n      return from;\n    }()\n  }]);\n\n  function AsyncPeekerator(iterator, first) {\n    _classCallCheck(this, AsyncPeekerator);\n\n    this[_] = {\n      iterator: iterator,\n      current: first,\n      index: 0\n    };\n  }\n\n  _createClass(AsyncPeekerator, [{\n    key: \"advance\",\n    value: function () {\n      var _advance = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {\n        var this_;\n        return _regeneratorRuntime.wrap(function _callee4$(_context4) {\n          while (1) {\n            switch (_context4.prev = _context4.next) {\n              case 0:\n                this_ = this[_];\n\n                if (this_.current.done) {\n                  _context4.next = 6;\n                  break;\n                }\n\n                this_.index++;\n                _context4.next = 5;\n                return this_.iterator.next();\n\n              case 5:\n                this_.current = _context4.sent;\n\n              case 6:\n                return _context4.abrupt(\"return\", this);\n\n              case 7:\n              case \"end\":\n                return _context4.stop();\n            }\n          }\n        }, _callee4, this);\n      }));\n\n      function advance() {\n        return _advance.apply(this, arguments);\n      }\n\n      return advance;\n    }()\n  }, {\n    key: \"return\",\n    value: function () {\n      var _return3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {\n        var this_;\n        return _regeneratorRuntime.wrap(function _callee5$(_context5) {\n          while (1) {\n            switch (_context5.prev = _context5.next) {\n              case 0:\n                this_ = this[_];\n\n                if (this.done) {\n                  _context5.next = 4;\n                  break;\n                }\n\n                _context5.next = 4;\n                return asyncCallReturn(this_.iterator);\n\n              case 4:\n                this_.current = {\n                  value: undefined,\n                  done: true\n                };\n                return _context5.abrupt(\"return\", this);\n\n              case 6:\n              case \"end\":\n                return _context5.stop();\n            }\n          }\n        }, _callee5, this);\n      }));\n\n      function _return() {\n        return _return3.apply(this, arguments);\n      }\n\n      return _return;\n    }()\n  }, {\n    key: \"asIterator\",\n    value: function asIterator() {\n      return new AsyncPeekeratorIterator(this);\n    }\n  }, {\n    key: \"current\",\n    get: function get() {\n      return this[_].current;\n    }\n  }, {\n    key: \"value\",\n    get: function get() {\n      return this[_].current.value;\n    }\n  }, {\n    key: \"done\",\n    get: function get() {\n      return this[_].current.done;\n    }\n  }, {\n    key: \"index\",\n    get: function get() {\n      return this[_].index;\n    }\n  }]);\n\n  return AsyncPeekerator;\n}();\n\nexports.AsyncPeekerator = AsyncPeekerator;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _wrapAsyncGenerator = require(\"@babel/runtime/helpers/wrapAsyncGenerator\");\n\nvar _awaitAsyncGenerator = require(\"@babel/runtime/helpers/awaitAsyncGenerator\");\n\nvar _asyncIterator = require(\"@babel/runtime/helpers/asyncIterator\");\n\nvar _asyncGeneratorDelegate = require(\"@babel/runtime/helpers/asyncGeneratorDelegate\");\n\nfunction asyncWrap(_x) {\n  return _asyncWrap.apply(this, arguments);\n}\n\nexports.asyncWrap = asyncWrap;\n\nfunction _asyncWrap() {\n  _asyncWrap = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(source) {\n    return _regeneratorRuntime.wrap(function _callee$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            return _context.delegateYield(_asyncGeneratorDelegate(_asyncIterator(source), _awaitAsyncGenerator), \"t0\", 1);\n\n          case 1:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, _callee);\n  }));\n  return _asyncWrap.apply(this, arguments);\n}\n\nfunction asyncNullableWrap(_x2) {\n  return _asyncNullableWrap.apply(this, arguments);\n}\n\nexports.asyncNullableWrap = asyncNullableWrap;\n\nfunction _asyncNullableWrap() {\n  _asyncNullableWrap = _wrapAsyncGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(source) {\n    return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n      while (1) {\n        switch (_context2.prev = _context2.next) {\n          case 0:\n            if (!(source != null)) {\n              _context2.next = 2;\n              break;\n            }\n\n            return _context2.delegateYield(_asyncGeneratorDelegate(_asyncIterator(source), _awaitAsyncGenerator), \"t0\", 2);\n\n          case 2:\n          case \"end\":\n            return _context2.stop();\n        }\n      }\n    }, _callee2);\n  }));\n  return _asyncNullableWrap.apply(this, arguments);\n}","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar _inherits = require(\"@babel/runtime/helpers/inherits\");\n\nvar _possibleConstructorReturn = require(\"@babel/runtime/helpers/possibleConstructorReturn\");\n\nvar _getPrototypeOf = require(\"@babel/runtime/helpers/getPrototypeOf\");\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nvar _require = require('./iterable-iterator.js'),\n    IterableIterator = _require.IterableIterator;\n\nvar _require2 = require('./parts-iterator.js'),\n    PartsIterator = _require2.PartsIterator;\n\nvar Bisector = /*#__PURE__*/function (_IterableIterator) {\n  _inherits(Bisector, _IterableIterator);\n\n  var _super = _createSuper(Bisector);\n\n  function Bisector(source, strategy, options) {\n    var _this;\n\n    _classCallCheck(this, Bisector);\n\n    _this = _super.call(this);\n    _this.source = source;\n    _this.strategy = strategy;\n    _this.options = options;\n    _this.partsIterator = null;\n    _this.firstPart = null;\n    _this.secondPart = null;\n    _this.currentIdx = 0;\n    return _this;\n  }\n\n  _createClass(Bisector, [{\n    key: \"setupFirst\",\n    value: function setupFirst() {\n      var source = this.source,\n          strategy = this.strategy,\n          options = this.options;\n      this.partsIterator = this.partsIterator || new PartsIterator(source, strategy, options);\n\n      if (!this.firstPart) {\n        var step = this.partsIterator.next();\n        this.firstPart = step.done ? [] : step.value;\n      }\n    }\n  }, {\n    key: \"next\",\n    value: function next() {\n      var self = this;\n\n      switch (this.currentIdx++) {\n        case 0:\n          return {\n            value: /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {\n              return _regeneratorRuntime.wrap(function _callee$(_context) {\n                while (1) {\n                  switch (_context.prev = _context.next) {\n                    case 0:\n                      self.setupFirst();\n                      return _context.delegateYield(self.firstPart, \"t0\", 2);\n\n                    case 2:\n                    case \"end\":\n                      return _context.stop();\n                  }\n                }\n              }, _callee);\n            })(),\n            done: false\n          };\n\n        case 1:\n          return {\n            value: /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {\n              var step;\n              return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n                while (1) {\n                  switch (_context2.prev = _context2.next) {\n                    case 0:\n                      self.setupFirst();\n                      step = self.partsIterator.next();\n                      self.secondPart = step.done ? [] : step.value;\n                      return _context2.delegateYield(self.secondPart, \"t0\", 4);\n\n                    case 4:\n                    case \"end\":\n                      return _context2.stop();\n                  }\n                }\n              }, _callee2);\n            })(),\n            done: false\n          };\n\n        default:\n          return {\n            value: undefined,\n            done: true\n          };\n      }\n    }\n  }, {\n    key: \"return\",\n    value: function _return() {\n      if (this.currentIdx === 1) {\n        throw new Error('You must take both parts of a bisector or neither.');\n      }\n\n      return {\n        value: undefined,\n        done: true\n      };\n    }\n  }]);\n\n  return Bisector;\n}(IterableIterator);\n\nexports.Bisector = Bisector;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar _sourceBuffer = Symbol('sourceBuffer');\n\nvar ReadOnlyCircularBuffer = /*#__PURE__*/function () {\n  function ReadOnlyCircularBuffer(sourceBuffer) {\n    _classCallCheck(this, ReadOnlyCircularBuffer);\n\n    this[_sourceBuffer] = sourceBuffer;\n  }\n\n  _createClass(ReadOnlyCircularBuffer, [{\n    key: \"get\",\n    value: function get(idx) {\n      return this[_sourceBuffer].get(idx);\n    }\n  }, {\n    key: \"peek\",\n    value: function peek() {\n      return this[_sourceBuffer].peek();\n    }\n  }, {\n    key: \"isFull\",\n    value: function isFull() {\n      return this[_sourceBuffer].isFull();\n    }\n  }, {\n    key: Symbol.iterator,\n    value: function value() {\n      return this[_sourceBuffer][Symbol.iterator]();\n    }\n  }, {\n    key: \"size\",\n    get: function get() {\n      return this[_sourceBuffer].size;\n    }\n  }, {\n    key: \"capacity\",\n    get: function get() {\n      return this[_sourceBuffer].capacity;\n    }\n  }]);\n\n  return ReadOnlyCircularBuffer;\n}();\n\nexports.ReadOnlyCircularBuffer = ReadOnlyCircularBuffer;\n\nvar CircularBuffer = /*#__PURE__*/function () {\n  function CircularBuffer(size) {\n    _classCallCheck(this, CircularBuffer);\n\n    this._array = new Array(size);\n    this._head = size - 1;\n    this.size = 0;\n  }\n\n  _createClass(CircularBuffer, [{\n    key: \"push\",\n    value: function push(value) {\n      var array = this._array;\n      var head = this._head = (this._head + 1) % array.length;\n      var displacedValue = array[head];\n      array[head] = value;\n\n      if (this.isFull()) {\n        return displacedValue;\n      } else {\n        this.size++;\n        return undefined;\n      }\n    }\n  }, {\n    key: \"shift\",\n    value: function shift() {\n      if (!this.size) return undefined;\n      var value = this.get(0);\n      this.size--;\n      return value;\n    }\n  }, {\n    key: \"peek\",\n    value: function peek() {\n      return this.get(0);\n    }\n  }, {\n    key: \"fill\",\n    value: function fill(filler) {\n      this._array.fill(filler);\n\n      this.size = this._array.length;\n    }\n  }, {\n    key: \"get\",\n    value: function get(idx) {\n      if (idx >= this.size) return undefined;\n      var array = this._array;\n      var head = this._head;\n      var index = (array.length + head - this.size + 1 + idx) % array.length;\n      return array[index];\n    }\n  }, {\n    key: \"isFull\",\n    value: function isFull() {\n      return this.size === this._array.length;\n    }\n  }, {\n    key: Symbol.iterator,\n    value: /*#__PURE__*/_regeneratorRuntime.mark(function value() {\n      var i;\n      return _regeneratorRuntime.wrap(function value$(_context) {\n        while (1) {\n          switch (_context.prev = _context.next) {\n            case 0:\n              i = 0;\n\n            case 1:\n              if (!(i < this.size)) {\n                _context.next = 7;\n                break;\n              }\n\n              _context.next = 4;\n              return this.get(i);\n\n            case 4:\n              i++;\n              _context.next = 1;\n              break;\n\n            case 7:\n            case \"end\":\n              return _context.stop();\n          }\n        }\n      }, value, this);\n    })\n  }, {\n    key: \"capacity\",\n    get: function get() {\n      return this._array.length;\n    }\n  }]);\n\n  return CircularBuffer;\n}();\n\nexports.CircularBuffer = CircularBuffer;","function defaultCompareOrder(a, b) {\n  if (a > b) {\n    return 1;\n  } else if (a < b) {\n    return -1;\n  } else {\n    return 0;\n  }\n}\n\nexports.defaultCompareOrder = defaultCompareOrder;","var _toConsumableArray = require(\"@babel/runtime/helpers/toConsumableArray\");\n\nfunction curry(fn) {\n  var expectedArgsLength = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : fn.length;\n  var appliedArgs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];\n  return function () {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    if (expectedArgsLength <= args.length) {\n      return fn.apply(void 0, _toConsumableArray(appliedArgs).concat(args));\n    }\n\n    return curry(fn, expectedArgsLength - args.length, [].concat(_toConsumableArray(appliedArgs), args));\n  };\n}\n\nexports.curry = curry;\n\nfunction variadicCurryWithValidationInner(config, args) {\n  var fn = config.fn,\n      validateArgs = config.validateArgs,\n      variadic = config.variadic,\n      reduces = config.reduces,\n      growRight = config.growRight,\n      minArgs = config.minArgs,\n      maxArgs = config.maxArgs,\n      isIterable = config.isIterable,\n      iterableType = config.iterableType,\n      applyOnIterableArgs = config.applyOnIterableArgs,\n      IterableClass = config.IterableClass;\n\n  if (args.length > minArgs) {\n    var argsIterable = true;\n    var iterableArgsStart = variadic ? args.findIndex(function (arg, i) {\n      return isIterable(arg) && i >= minArgs;\n    }) : Math.min(maxArgs, args.length - 1);\n    var iterableArgsEnd = variadic ? args.length : iterableArgsStart + 1;\n\n    if (variadic) {\n      for (var i = iterableArgsStart; i < args.length; i++) {\n        argsIterable = argsIterable && isIterable(args[i]);\n      }\n    } else {\n      argsIterable = isIterable(args[iterableArgsStart]);\n    }\n\n    if (args.length > maxArgs && (iterableArgsStart === -1 || !argsIterable)) {\n      var iterableTypeOrNames = variadic ? \"...\".concat(iterableType, \"s\") : iterableType;\n      var baseMessage = \"\".concat(fn.name, \" takes up to \").concat(maxArgs, \" arguments, followed by \").concat(iterableTypeOrNames, \". \") + \"You already passed \".concat(args.length, \" arguments\");\n\n      if (variadic) {\n        throw new Error(\"\".concat(baseMessage, \" and the following arguments were not all \").concat(iterableType, \"s\"));\n      } else {\n        throw new Error(\"\".concat(baseMessage, \" and the last argument was not \").concat(iterableType));\n      }\n    }\n\n    if (iterableArgsStart >= 0 && argsIterable) {\n      for (var _i = iterableArgsStart; _i < iterableArgsEnd; _i++) {\n        args[_i] = applyOnIterableArgs(args[_i]);\n      }\n\n      var iterablesArg = variadic ? args.slice(iterableArgsStart) : args[iterableArgsStart];\n      args.splice(iterableArgsStart);\n\n      if (!growRight) {\n        args.reverse();\n      }\n\n      args.unshift(iterablesArg);\n      validateArgs(args);\n      return reduces ? fn.apply(void 0, _toConsumableArray(args)) : new IterableClass(fn, args);\n    } else {}\n  }\n\n  return variadicCurryWithValidation(config, args);\n}\n\nfunction variadicCurryWithValidation(config) {\n  var previousArgs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n  return function () {\n    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      args[_key2] = arguments[_key2];\n    }\n\n    if (args.length === 0) {\n      throw new Error('Cannot make a partial application with no arguments');\n    }\n\n    args.unshift.apply(args, _toConsumableArray(previousArgs));\n    return variadicCurryWithValidationInner(config, args);\n  };\n}\n\nexports.variadicCurryWithValidation = variadicCurryWithValidation;","function delay(ms, output) {\n  return new Promise(function (resolve, reject) {\n    return setTimeout(function () {\n      if (output instanceof Error) {\n        reject(output);\n      } else {\n        resolve(output);\n      }\n    }, ms);\n  });\n}\n\nexports.delay = delay;","var _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar _inherits = require(\"@babel/runtime/helpers/inherits\");\n\nvar _possibleConstructorReturn = require(\"@babel/runtime/helpers/possibleConstructorReturn\");\n\nvar _getPrototypeOf = require(\"@babel/runtime/helpers/getPrototypeOf\");\n\nvar _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nvar _require = require('./iterable-iterator.js'),\n    IterableIterator = _require.IterableIterator;\n\nvar _require2 = require('./iterable.js'),\n    callReturn = _require2.callReturn;\n\nvar QueueItem = function QueueItem(step) {\n  _classCallCheck(this, QueueItem);\n\n  this.step = step;\n  this.next = null;\n};\n\nvar Fork = /*#__PURE__*/function (_IterableIterator) {\n  _inherits(Fork, _IterableIterator);\n\n  var _super = _createSuper(Fork);\n\n  function Fork(head, exchange) {\n    var _this;\n\n    _classCallCheck(this, Fork);\n\n    _this = _super.call(this);\n    _this.head = head;\n    _this.done = false;\n    _this.exchange = exchange;\n    return _this;\n  }\n\n  _createClass(Fork, [{\n    key: \"next\",\n    value: function next() {\n      var done = this.done,\n          exchange = this.exchange;\n\n      if (done) {\n        return {\n          value: undefined,\n          done: done\n        };\n      } else {\n        var head = this.head;\n        if (!head.next) exchange.fetch();\n        head = head.next;\n        var _head = head,\n            step = _head.step;\n        this.done = step.done;\n        this.head = head;\n        return step;\n      }\n    }\n  }, {\n    key: \"return\",\n    value: function _return() {\n      var done = this.done,\n          exchange = this.exchange;\n      if (!done) exchange[\"return\"]();\n      return {\n        value: undefined,\n        done: true\n      };\n    }\n  }]);\n\n  return Fork;\n}(IterableIterator);\n\nvar Exchange = /*#__PURE__*/function () {\n  function Exchange(iterator) {\n    _classCallCheck(this, Exchange);\n\n    this.iterator = iterator;\n    this.tail = new QueueItem(null);\n    this.head = this.tail;\n    this.forks = 0;\n  }\n\n  _createClass(Exchange, [{\n    key: \"fork\",\n    value: function fork() {\n      ++this.forks;\n      return new Fork(this.tail, this);\n    }\n  }, {\n    key: \"advance\",\n    value: function advance() {\n      this.tail = this.tail.next;\n    }\n  }, {\n    key: \"fetch\",\n    value: function fetch() {\n      var step = this.iterator.next();\n      var newItem = new QueueItem(step);\n      this.head.next = this.head = newItem;\n    }\n  }, {\n    key: \"return\",\n    value: function _return() {\n      --this.forks;\n\n      if (this.forks === 0) {\n        callReturn(this.iterator);\n      }\n\n      return {\n        value: undefined,\n        done: true\n      };\n    }\n  }]);\n\n  return Exchange;\n}();\n\nexports.Exchange = Exchange;","var _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar _inherits = require(\"@babel/runtime/helpers/inherits\");\n\nvar _possibleConstructorReturn = require(\"@babel/runtime/helpers/possibleConstructorReturn\");\n\nvar _getPrototypeOf = require(\"@babel/runtime/helpers/getPrototypeOf\");\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nvar _require = require('./parts-iterator.js'),\n    PartsIterator = _require.PartsIterator,\n    PartIterator = _require.PartIterator;\n\nvar _require2 = require('./symbols.js'),\n    split = _require2.split;\n\nvar GroupsIterator = /*#__PURE__*/function (_PartsIterator) {\n  _inherits(GroupsIterator, _PartsIterator);\n\n  var _super = _createSuper(GroupsIterator);\n\n  function GroupsIterator() {\n    _classCallCheck(this, GroupsIterator);\n\n    return _super.apply(this, arguments);\n  }\n\n  _createClass(GroupsIterator, [{\n    key: \"next\",\n    value: function next() {\n      if (!this.initialized) this.init();\n      var spliterator = this.spliterator;\n\n      if (this.currentPart !== null) {\n        if (spliterator.value !== split || spliterator.current === this.splitStep) {\n          this.currentPart.inactive = true;\n\n          while (!spliterator.done && spliterator.value !== split) {\n            spliterator.advance();\n          }\n        }\n      }\n\n      if (spliterator.done) {\n        return {\n          value: undefined,\n          done: true\n        };\n      }\n\n      spliterator.advance();\n\n      if (spliterator.done || spliterator.value === split) {\n        throw new Error('Unexpected empty group');\n      }\n\n      var key = spliterator.value;\n      spliterator.advance();\n      this.splitStep = spliterator.current;\n      this.currentPart = new PartIterator(this);\n      return {\n        value: [key, this.currentPart],\n        done: false\n      };\n    }\n  }]);\n\n  return GroupsIterator;\n}(PartsIterator);\n\nexports.GroupsIterator = GroupsIterator;","var _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar IterableIterator = /*#__PURE__*/function () {\n  function IterableIterator() {\n    _classCallCheck(this, IterableIterator);\n  }\n\n  _createClass(IterableIterator, [{\n    key: Symbol.iterator,\n    value: function value() {\n      return this;\n    }\n  }]);\n\n  return IterableIterator;\n}();\n\nexports.IterableIterator = IterableIterator;","var _defineProperty = require(\"@babel/runtime/helpers/defineProperty\");\n\nvar _toConsumableArray = require(\"@babel/runtime/helpers/toConsumableArray\");\n\nvar _Object$assign;\n\nvar _require = require('../impls/is-iterable/is-iterable.js'),\n    isIterable = _require.isIterable;\n\nvar _require2 = require('../impls/is-loopable/is-loopable.js'),\n    isLoopable = _require2.isLoopable;\n\nvar _require3 = require('../impls/is-wrappable/is-wrappable.js'),\n    isWrappable = _require3.isWrappable;\n\nvar _require4 = require('./wrap.js'),\n    wrap = _require4.nullableWrap;\n\nvar _require5 = require('./curry.js'),\n    variadicCurryWithValidation = _require5.variadicCurryWithValidation;\n\nvar _require6 = require('./symbols.js'),\n    _ = _require6._,\n    __iterate = _require6.__iterate;\n\nexports.wrap = wrap;\nexports.isIterable = isIterable;\nexports.isLoopable = isLoopable;\nexports.isWrappable = isWrappable;\n\nfunction ensureIterable(value) {\n  if (!isWrappable(value)) {\n    if (typeof value.next === 'function') {\n      throw new TypeError('iter-tools received a value that looked like an iterator but was not iterable. Get help fixing this: https://github.com/iter-tools/iter-tools/wiki/Making-iterators-iterable');\n    } else throw new TypeError('Expected an iterable, null, or undefined');\n  } else if (isIterable(value)) {\n    return value;\n  } else {\n    return wrap(value);\n  }\n}\n\nexports.ensureIterable = ensureIterable;\n\nfunction callReturn(iterator) {\n  if ('return' in iterator) iterator[\"return\"]();\n}\n\nexports.callReturn = callReturn;\n\nfunction BaseIterableIterator(fn, args) {\n  this[_] = {\n    fn: fn,\n    args: args,\n    staticIterator: null\n  };\n}\n\nexports.BaseIterableIterator = BaseIterableIterator;\nObject.assign(BaseIterableIterator.prototype, (_Object$assign = {\n  constructor: BaseIterableIterator\n}, _defineProperty(_Object$assign, __iterate, function () {\n  var _this$_ = this[_],\n      fn = _this$_.fn,\n      args = _this$_.args;\n  return fn.apply(void 0, _toConsumableArray(args));\n}), _defineProperty(_Object$assign, \"next\", function next() {\n  var this_ = this[_];\n  this_.staticIterator = this_.staticIterator || this[__iterate]();\n  return this_.staticIterator.next();\n}), _defineProperty(_Object$assign, \"return\", function _return(value) {\n  var this_ = this[_];\n  this_.staticIterator = this_.staticIterator || this[__iterate]();\n  return this_.staticIterator[\"return\"](value);\n}), _defineProperty(_Object$assign, \"throw\", function _throw(error) {\n  var this_ = this[_];\n  this_.staticIterator = this_.staticIterator || this[__iterate]();\n  return this_.staticIterator[\"throw\"](error);\n}), _Object$assign));\n\nfunction IterableIterator() {\n  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n    args[_key] = arguments[_key];\n  }\n\n  BaseIterableIterator.apply(this, args);\n}\n\nexports.IterableIterator = IterableIterator;\nIterableIterator.prototype = Object.assign(Object.create(BaseIterableIterator.prototype), _defineProperty({\n  constructor: IterableIterator\n}, Symbol.iterator, function () {\n  return this[__iterate]();\n}));\n\nfunction makeFunctionConfig(fn) {\n  var fnConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  var _fnConfig$validateArg = fnConfig.validateArgs,\n      validateArgs = _fnConfig$validateArg === void 0 ? function (_) {} : _fnConfig$validateArg,\n      _fnConfig$variadic = fnConfig.variadic,\n      variadic = _fnConfig$variadic === void 0 ? false : _fnConfig$variadic,\n      _fnConfig$reduces = fnConfig.reduces,\n      reduces = _fnConfig$reduces === void 0 ? false : _fnConfig$reduces,\n      _fnConfig$growRight = fnConfig.growRight,\n      growRight = _fnConfig$growRight === void 0 ? false : _fnConfig$growRight,\n      _fnConfig$minArgs = fnConfig.minArgs,\n      minArgs = _fnConfig$minArgs === void 0 ? fn.length - 1 : _fnConfig$minArgs,\n      _fnConfig$maxArgs = fnConfig.maxArgs,\n      maxArgs = _fnConfig$maxArgs === void 0 ? fn.length - 1 : _fnConfig$maxArgs,\n      _fnConfig$applyOnIter = fnConfig.applyOnIterableArgs,\n      applyOnIterableArgs = _fnConfig$applyOnIter === void 0 ? ensureIterable : _fnConfig$applyOnIter;\n  return {\n    fn: fn,\n    validateArgs: validateArgs,\n    variadic: variadic,\n    reduces: reduces,\n    growRight: growRight,\n    minArgs: minArgs,\n    maxArgs: maxArgs,\n    isIterable: isWrappable,\n    iterableType: 'iterable',\n    applyOnIterableArgs: applyOnIterableArgs,\n    IterableClass: IterableIterator\n  };\n}\n\nfunction cache(it) {\n  return _toConsumableArray(it);\n}\n\nexports.cache = cache;\n\nfunction wrapWithIterableIterator(fn) {\n  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n      _ref$validateArgs = _ref.validateArgs,\n      validateArgs = _ref$validateArgs === void 0 ? function (_) {\n    return _;\n  } : _ref$validateArgs;\n\n  return function () {\n    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      args[_key2] = arguments[_key2];\n    }\n\n    validateArgs(args);\n    return new IterableIterator(fn, args);\n  };\n}\n\nexports.wrapWithIterableIterator = wrapWithIterableIterator;\n\nvar iterableCurry = function iterableCurry(fn, config) {\n  return variadicCurryWithValidation(makeFunctionConfig(fn, config));\n};\n\nexports.iterableCurry = iterableCurry;","function isInteger(value) {\n  var nonZero = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n  return typeof value === 'number' && !isNaN(value) && isFinite(value) && !(nonZero && value === 0);\n}\n\nexports.isInteger = isInteger;\n\nfunction isPositiveInteger(value) {\n  var nonZero = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n  return isInteger(value) && (nonZero ? value > 0 : value >= 0);\n}\n\nexports.isPositiveInteger = isPositiveInteger;\n\nfunction isIntegerOrInfinite(value) {\n  var nonZero = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n  return typeof value === 'number' && !isNaN(value) && !(nonZero && value === 0);\n}\n\nexports.isIntegerOrInfinite = isIntegerOrInfinite;","function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction parallelEach(iterable, cb) {\n  var _iterator = _createForOfIteratorHelper(iterable),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var value = _step.value;\n      cb(value);\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n}\n\nexports.parallelEach = parallelEach;","var _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar _inherits = require(\"@babel/runtime/helpers/inherits\");\n\nvar _possibleConstructorReturn = require(\"@babel/runtime/helpers/possibleConstructorReturn\");\n\nvar _getPrototypeOf = require(\"@babel/runtime/helpers/getPrototypeOf\");\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nvar _require = require('./symbols.js'),\n    split = _require.split;\n\nvar _require2 = require('./iterable-iterator.js'),\n    IterableIterator = _require2.IterableIterator;\n\nvar _require3 = require('./peekerator.js'),\n    Peekerator = _require3.Peekerator;\n\nvar PartIterator = /*#__PURE__*/function (_IterableIterator) {\n  _inherits(PartIterator, _IterableIterator);\n\n  var _super = _createSuper(PartIterator);\n\n  function PartIterator(partsIterator) {\n    var _this;\n\n    _classCallCheck(this, PartIterator);\n\n    _this = _super.call(this);\n    _this.partsIterator = partsIterator;\n    _this.inactive = false;\n    _this.done = false;\n    return _this;\n  }\n\n  _createClass(PartIterator, [{\n    key: \"assertActive\",\n    value: function assertActive() {\n      if (this.inactive && !this.done) {\n        throw new Error('Cannot take from this split part. It is no longer the active part.');\n      }\n    }\n  }, {\n    key: \"next\",\n    value: function next() {\n      var spliterator = this.partsIterator.spliterator;\n      var current = spliterator.current;\n      this.assertActive();\n\n      if (this.done || current.done || current.value === split) {\n        this.done = true;\n        this.partsIterator.maybeReturnSource();\n        return {\n          value: undefined,\n          done: true\n        };\n      } else {\n        spliterator.advance();\n        return current;\n      }\n    }\n  }, {\n    key: \"return\",\n    value: function _return() {\n      this.done = true;\n      this.partsIterator.maybeReturnSource();\n      return {\n        value: undefined,\n        done: true\n      };\n    }\n  }, {\n    key: \"throw\",\n    value: function _throw() {\n      return this[\"return\"]();\n    }\n  }]);\n\n  return PartIterator;\n}(IterableIterator);\n\nexports.PartIterator = PartIterator;\n\nvar PartsIterator = /*#__PURE__*/function (_IterableIterator2) {\n  _inherits(PartsIterator, _IterableIterator2);\n\n  var _super2 = _createSuper(PartsIterator);\n\n  function PartsIterator(source, strategy, options) {\n    var _this2;\n\n    _classCallCheck(this, PartsIterator);\n\n    _this2 = _super2.call(this);\n    _this2.source = source;\n    _this2.strategy = strategy;\n    _this2.options = options;\n    _this2.initialized = false;\n    _this2.returned = false;\n    _this2.spliterator = null;\n    _this2.currentPart = null;\n    _this2.splitStep = null;\n    return _this2;\n  }\n\n  _createClass(PartsIterator, [{\n    key: \"init\",\n    value: function init() {\n      this.initialized = true;\n      var source = this.source,\n          strategy = this.strategy,\n          options = this.options;\n      this.spliterator = Peekerator.from(strategy(split, options, source));\n    }\n  }, {\n    key: \"maybeReturnSource\",\n    value: function maybeReturnSource() {\n      if (this.spliterator && this.returned && this.currentPart.done) {\n        this.spliterator[\"return\"]();\n      }\n    }\n  }, {\n    key: \"next\",\n    value: function next() {\n      if (!this.initialized) this.init();\n      var spliterator = this.spliterator;\n\n      if (spliterator.done) {\n        return {\n          value: undefined,\n          done: true\n        };\n      }\n\n      if (this.currentPart !== null) {\n        if (spliterator.value !== split || spliterator.current === this.splitStep) {\n          this.currentPart.inactive = true;\n\n          while (!spliterator.done && spliterator.value !== split) {\n            spliterator.advance();\n          }\n        }\n\n        spliterator.advance();\n      }\n\n      this.splitStep = spliterator.current;\n      this.currentPart = new PartIterator(this);\n      return {\n        value: this.currentPart,\n        done: false\n      };\n    }\n  }, {\n    key: \"return\",\n    value: function _return(value) {\n      this.returned = true;\n      this.maybeReturnSource();\n      return {\n        value: value,\n        done: true\n      };\n    }\n  }, {\n    key: \"throw\",\n    value: function _throw() {\n      return this[\"return\"]();\n    }\n  }]);\n\n  return PartsIterator;\n}(IterableIterator);\n\nexports.PartsIterator = PartsIterator;","var _construct = require(\"@babel/runtime/helpers/construct\");\n\nvar _classCallCheck = require(\"@babel/runtime/helpers/classCallCheck\");\n\nvar _createClass = require(\"@babel/runtime/helpers/createClass\");\n\nvar _require = require('./iterable.js'),\n    ensureIterable = _require.ensureIterable,\n    callReturn = _require.callReturn;\n\nvar _ = Symbol[\"for\"]('_');\n\nvar PeekeratorIterator = /*#__PURE__*/function () {\n  function PeekeratorIterator(peekr) {\n    _classCallCheck(this, PeekeratorIterator);\n\n    this.peekr = peekr;\n  }\n\n  _createClass(PeekeratorIterator, [{\n    key: \"next\",\n    value: function next() {\n      var peekr = this.peekr;\n      var current = peekr.current;\n      peekr.advance();\n      return current;\n    }\n  }, {\n    key: \"return\",\n    value: function _return() {\n      this.peekr[\"return\"]();\n      return {\n        value: undefined,\n        done: true\n      };\n    }\n  }, {\n    key: Symbol.iterator,\n    value: function value() {\n      return this;\n    }\n  }]);\n\n  return PeekeratorIterator;\n}();\n\nvar Peekerator = /*#__PURE__*/function () {\n  _createClass(Peekerator, null, [{\n    key: \"from\",\n    value: function from(iterable) {\n      var iterator = ensureIterable(iterable)[Symbol.iterator]();\n      var first = iterator.next();\n\n      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n        args[_key - 1] = arguments[_key];\n      }\n\n      return _construct(this, [iterator, first].concat(args));\n    }\n  }]);\n\n  function Peekerator(iterator, first) {\n    _classCallCheck(this, Peekerator);\n\n    this[_] = {\n      iterator: iterator,\n      current: first,\n      index: 0\n    };\n  }\n\n  _createClass(Peekerator, [{\n    key: \"advance\",\n    value: function advance() {\n      var this_ = this[_];\n\n      if (!this_.current.done) {\n        this_.index++;\n        this_.current = this_.iterator.next();\n      }\n\n      return this;\n    }\n  }, {\n    key: \"return\",\n    value: function _return() {\n      var this_ = this[_];\n\n      if (!this.done) {\n        callReturn(this_.iterator);\n      }\n\n      this_.current = {\n        value: undefined,\n        done: true\n      };\n      return this;\n    }\n  }, {\n    key: \"asIterator\",\n    value: function asIterator() {\n      return new PeekeratorIterator(this);\n    }\n  }, {\n    key: \"current\",\n    get: function get() {\n      return this[_].current;\n    }\n  }, {\n    key: \"value\",\n    get: function get() {\n      return this[_].current.value;\n    }\n  }, {\n    key: \"done\",\n    get: function get() {\n      return this[_].current.done;\n    }\n  }, {\n    key: \"index\",\n    get: function get() {\n      return this[_].index;\n    }\n  }]);\n\n  return Peekerator;\n}();\n\nexports.Peekerator = Peekerator;","var _ = Symbol[\"for\"]('_');\n\nexports._ = _;\n\nvar __iterate = Symbol('__iterate');\n\nexports.__iterate = __iterate;\nvar split = Symbol('split');\nexports.split = split;","var _regeneratorRuntime = require(\"@babel/runtime/regenerator\");\n\nvar _marked = /*#__PURE__*/_regeneratorRuntime.mark(wrap),\n    _marked2 = /*#__PURE__*/_regeneratorRuntime.mark(nullableWrap);\n\nfunction wrap(source) {\n  return _regeneratorRuntime.wrap(function wrap$(_context) {\n    while (1) {\n      switch (_context.prev = _context.next) {\n        case 0:\n          return _context.delegateYield(source, \"t0\", 1);\n\n        case 1:\n        case \"end\":\n          return _context.stop();\n      }\n    }\n  }, _marked);\n}\n\nexports.wrap = wrap;\n\nfunction nullableWrap(source) {\n  return _regeneratorRuntime.wrap(function nullableWrap$(_context2) {\n    while (1) {\n      switch (_context2.prev = _context2.next) {\n        case 0:\n          if (!(source != null)) {\n            _context2.next = 2;\n            break;\n          }\n\n          return _context2.delegateYield(source, \"t0\", 2);\n\n        case 2:\n        case \"end\":\n          return _context2.stop();\n      }\n    }\n  }, _marked2);\n}\n\nexports.nullableWrap = nullableWrap;","module.exports = require('../impls/$append/append.js').append;","module.exports = require('../impls/apply/apply.js').apply;","module.exports = require('../impls/array-first-or/array-first-or.js').arrayFirstOr;","module.exports = require('../impls/array-first/array-first.js').arrayFirst;","module.exports = require('../impls/array-from-async/array-from-async.js').arrayFromAsync;","module.exports = require('../impls/array-from/array-from.js').arrayFrom;","module.exports = require('../impls/array-last-or/array-last-or.js').arrayLastOr;","module.exports = require('../impls/array-last/array-last.js').arrayLast;","module.exports = require('../impls/array-reverse/array-reverse.js').arrayReverse;","module.exports = require('../impls/$append/async-append.js').asyncAppend;","module.exports = require('../impls/$batch/async-batch.js').asyncBatch;","module.exports = require('../impls/$bisect/async-bisect.js').asyncBisect;","module.exports = require('../impls/async-buffer/async-buffer.js').asyncBuffer;","module.exports = require('../impls/$collate/async-collate.js').asyncCollate;","module.exports = require('../impls/$compress/async-compress.js').asyncCompress;","module.exports = require('../impls/$concat/async-concat.js').asyncConcat;","module.exports = require('../impls/$consume/async-consume.js').asyncConsume;","module.exports = require('../impls/$cycle-times/async-cycle-times.js').asyncCycleTimes;","module.exports = require('../impls/$cycle/async-cycle.js').asyncCycle;","module.exports = require('../impls/$deep-equal/async-deep-equal.js').asyncDeepEqual;","module.exports = require('../impls/$distinct/async-distinct.js').asyncDistinct;","module.exports = require('../impls/$drop-while/async-drop-while.js').asyncDropWhile;","module.exports = require('../impls/$drop/async-drop.js').asyncDrop;","module.exports = require('../impls/$enumerate/async-enumerate.js').asyncEnumerate;","module.exports = require('../impls/$equal/async-equal.js').asyncEqual;","module.exports = require('../impls/$every/async-every.js').asyncEvery;","module.exports = require('../impls/$filter/async-filter.js').asyncFilter;","module.exports = require('../impls/$find-best-or/async-find-best-or.js').asyncFindBestOr;","module.exports = require('../impls/$find-best/async-find-best.js').asyncFindBest;","module.exports = require('../impls/$find-or/async-find-or.js').asyncFindOr;","module.exports = require('../impls/$find/async-find.js').asyncFind;","module.exports = require('../impls/$first-or/async-first-or.js').asyncFirstOr;","module.exports = require('../impls/$first/async-first.js').asyncFirst;","module.exports = require('../impls/$flat-map/async-flat-map.js').asyncFlatMap;","module.exports = require('../impls/$flat/async-flat.js').asyncFlat;","module.exports = require('../impls/$for-each/async-for-each.js').asyncForEach;","module.exports = require('../impls/$fork/async-fork.js').asyncFork;","module.exports = require('../impls/$forkerate/async-forkerate.js').asyncForkerate;","module.exports = require('../impls/$includes-any-seq/async-includes-any-seq.js').asyncIncludesAnySeq;","module.exports = require('../impls/$includes-any/async-includes-any.js').asyncIncludesAny;","module.exports = require('../impls/$includes-seq/async-includes-seq.js').asyncIncludesSeq;","module.exports = require('../impls/$includes/async-includes.js').asyncIncludes;","module.exports = require('../impls/async-interleave-ready/async-interleave-ready.js').asyncInterleaveReady;","module.exports = require('../impls/$interleave/async-interleave.js').asyncInterleave;","module.exports = require('../impls/$interpose-seq/async-interpose-seq.js').asyncInterposeSeq;","module.exports = require('../impls/$interpose/async-interpose.js').asyncInterpose;","module.exports = require('../impls/$is-empty/async-is-empty.js').asyncIsEmpty;","module.exports = require('../impls/$is-sorted/async-is-sorted.js').asyncIsSorted;","module.exports = require('../impls/$join-with-seq/async-join-with-seq.js').asyncJoinWithSeq;","module.exports = require('../impls/$join-with/async-join-with.js').asyncJoinWith;","module.exports = require('../impls/$join/async-join.js').asyncJoin;","module.exports = require('../impls/$map/async-map.js').asyncMap;","module.exports = require('../impls/$peekerate/async-peekerate.js').asyncPeekerate;","module.exports = require('../impls/$prepend/async-prepend.js').asyncPrepend;","module.exports = require('../impls/$reduce/async-reduce.js').asyncReduce;","module.exports = require('../impls/$reverse/async-reverse.js').asyncReverse;","module.exports = require('../impls/$round-robin/async-round-robin.js').asyncRoundRobin;","module.exports = require('../impls/$size/async-size.js').asyncSize;","module.exports = require('../impls/$slice/async-slice.js').asyncSlice;","module.exports = require('../impls/$some/async-some.js').asyncSome;","module.exports = require('../impls/$split-groups/async-split-groups.js').asyncSplitGroups;","module.exports = require('../impls/$split-on-any-seq/async-split-on-any-seq.js').asyncSplitOnAnySeq;","module.exports = require('../impls/$split-on-any/async-split-on-any.js').asyncSplitOnAny;","module.exports = require('../impls/$split-on-seq/async-split-on-seq.js').asyncSplitOnSeq;","module.exports = require('../impls/$split-on/async-split-on.js').asyncSplitOn;","module.exports = require('../impls/$split-when/async-split-when.js').asyncSplitWhen;","module.exports = require('../impls/$split/async-split.js').asyncSplit;","module.exports = require('../impls/$spliterate-grouped/async-spliterate-grouped.js').asyncSpliterateGrouped;","module.exports = require('../impls/$spliterate/async-spliterate.js').asyncSpliterate;","module.exports = require('../impls/$starts-with-any-seq/async-starts-with-any-seq.js').asyncStartsWithAnySeq;","module.exports = require('../impls/$starts-with-any/async-starts-with-any.js').asyncStartsWithAny;","module.exports = require('../impls/$starts-with-seq/async-starts-with-seq.js').asyncStartsWithSeq;","module.exports = require('../impls/$starts-with/async-starts-with.js').asyncStartsWith;","module.exports = require('../impls/$str/async-str.js').asyncStr;","module.exports = require('../impls/$take-last-or/async-take-last-or.js').asyncTakeLastOr;","module.exports = require('../impls/$take-last/async-take-last.js').asyncTakeLast;","module.exports = require('../impls/$take-sorted/async-take-sorted.js').asyncTakeSorted;","module.exports = require('../impls/$take-while/async-take-while.js').asyncTakeWhile;","module.exports = require('../impls/$take/async-take.js').asyncTake;","module.exports = require('../impls/$tap/async-tap.js').asyncTap;","module.exports = require('../impls/async-throttle/async-throttle.js').asyncThrottle;","module.exports = require('../impls/$to-array/async-to-array.js').asyncToArray;","module.exports = require('../impls/$to-object/async-to-object.js').asyncToObject;","module.exports = require('../impls/$window-ahead/async-window-ahead.js').asyncWindowAhead;","module.exports = require('../impls/$window-behind/async-window-behind.js').asyncWindowBehind;","module.exports = require('../impls/$window/async-window.js').asyncWindow;","module.exports = require('../impls/$wrap/async-wrap.js').asyncWrap;","module.exports = require('../impls/$zip-all/async-zip-all.js').asyncZipAll;","module.exports = require('../impls/$zip/async-zip.js').asyncZip;","module.exports = require('../impls/$batch/batch.js').batch;","module.exports = require('../impls/$bisect/bisect.js').bisect;","module.exports = require('../impls/call/call.js').call;","module.exports = require('../impls/$collate/collate.js').collate;","module.exports = require('../impls/compose/compose.js').compose;","module.exports = require('../impls/$compress/compress.js').compress;","module.exports = require('../impls/$concat/concat.js').concat;","module.exports = require('../impls/$consume/consume.js').consume;","module.exports = require('../impls/$cycle-times/cycle-times.js').cycleTimes;","module.exports = require('../impls/$cycle/cycle.js').cycle;","module.exports = require('../impls/$deep-equal/deep-equal.js').deepEqual;","module.exports = require('../impls/$distinct/distinct.js').distinct;","module.exports = require('../impls/$drop-while/drop-while.js').dropWhile;","module.exports = require('../impls/$drop/drop.js').drop;","module.exports = require('../impls/$enumerate/enumerate.js').enumerate;","module.exports = require('../impls/$equal/equal.js').equal;","module.exports = require('../impls/$every/every.js').every;","module.exports = require('../impls/exec-pipe/exec-pipe.js').execPipe;","module.exports = require('../impls/$filter/filter.js').filter;","module.exports = require('../impls/$find-best-or/find-best-or.js').findBestOr;","module.exports = require('../impls/$find-best/find-best.js').findBest;","module.exports = require('../impls/$find-or/find-or.js').findOr;","module.exports = require('../impls/$find/find.js').find;","module.exports = require('../impls/first-highest/first-highest.js').firstHighest;","module.exports = require('../impls/first-lowest/first-lowest.js').firstLowest;","module.exports = require('../impls/$first-or/first-or.js').firstOr;","module.exports = require('../impls/$first/first.js').first;","module.exports = require('../impls/$flat-map/flat-map.js').flatMap;","module.exports = require('../impls/$flat/flat.js').flat;","module.exports = require('../impls/$for-each/for-each.js').forEach;","module.exports = require('../impls/$fork/fork.js').fork;","module.exports = require('../impls/$forkerate/forkerate.js').forkerate;","module.exports = require('../impls/get-size/get-size.js').getSize;","module.exports = require('../impls/$includes-any-seq/includes-any-seq.js').includesAnySeq;","module.exports = require('../impls/$includes-any/includes-any.js').includesAny;","module.exports = require('../impls/$includes-seq/includes-seq.js').includesSeq;","module.exports = require('../impls/$includes/includes.js').includes;","module.exports = require('../impls/$interleave/interleave.js').interleave;","module.exports = require('../impls/$interpose-seq/interpose-seq.js').interposeSeq;","module.exports = require('../impls/$interpose/interpose.js').interpose;","module.exports = require('../impls/is-array/is-array.js').isArray;","module.exports = require('../impls/is-async-iterable/is-async-iterable.js').isAsyncIterable;","module.exports = require('../impls/is-async-loopable/is-async-loopable.js').isAsyncLoopable;","module.exports = require('../impls/is-async-wrappable/is-async-wrappable.js').isAsyncWrappable;","module.exports = require('../impls/$is-empty/is-empty.js').isEmpty;","module.exports = require('../impls/is-iterable/is-iterable.js').isIterable;","module.exports = require('../impls/is-loopable/is-loopable.js').isLoopable;","module.exports = require('../impls/is-nil/is-nil.js').isNil;","module.exports = require('../impls/is-null/is-null.js').isNull;","module.exports = require('../impls/is-object/is-object.js').isObject;","module.exports = require('../impls/$is-sorted/is-sorted.js').isSorted;","module.exports = require('../impls/is-string/is-string.js').isString;","module.exports = require('../impls/is-undefined/is-undefined.js').isUndefined;","module.exports = require('../impls/is-wrappable/is-wrappable.js').isWrappable;","module.exports = require('../impls/$join-with-seq/join-with-seq.js').joinWithSeq;","module.exports = require('../impls/$join-with/join-with.js').joinWith;","module.exports = require('../impls/$join/join.js').join;","module.exports = require('../impls/last-highest/last-highest.js').lastHighest;","module.exports = require('../impls/last-lowest/last-lowest.js').lastLowest;","module.exports = require('../impls/$map/map.js').map;","module.exports = require('../impls/not-array/not-array.js').notArray;","module.exports = require('../impls/not-async-iterable/not-async-iterable.js').notAsyncIterable;","module.exports = require('../impls/not-async-loopable/not-async-loopable.js').notAsyncLoopable;","module.exports = require('../impls/not-async-wrappable/not-async-wrappable.js').notAsyncWrappable;","module.exports = require('../impls/not-iterable/not-iterable.js').notIterable;","module.exports = require('../impls/not-loopable/not-loopable.js').notLoopable;","module.exports = require('../impls/not-nil/not-nil.js').notNil;","module.exports = require('../impls/not-null/not-null.js').notNull;","module.exports = require('../impls/not-object/not-object.js').notObject;","module.exports = require('../impls/not-string/not-string.js').notString;","module.exports = require('../impls/not-undefined/not-undefined.js').notUndefined;","module.exports = require('../impls/not-wrappable/not-wrappable.js').notWrappable;","module.exports = require('../impls/object-entries/object-entries.js').objectEntries;","module.exports = require('../impls/object-from-async/object-from-async.js').objectFromAsync;","module.exports = require('../impls/object-from/object-from.js').objectFrom;","module.exports = require('../impls/object-keys/object-keys.js').objectKeys;","module.exports = require('../impls/object-values/object-values.js').objectValues;","module.exports = require('../impls/$peekerate/peekerate.js').peekerate;","module.exports = require('../impls/pipe/pipe.js').pipe;","module.exports = require('../impls/$prepend/prepend.js').prepend;","module.exports = require('../impls/range/range.js').range;","module.exports = require('../impls/$reduce/reduce.js').reduce;","module.exports = require('../impls/repeat-times/repeat-times.js').repeatTimes;","module.exports = require('../impls/repeat/repeat.js').repeat;","module.exports = require('../impls/$reverse/reverse.js').reverse;","module.exports = require('../impls/$round-robin/round-robin.js').roundRobin;","module.exports = require('../impls/$size/size.js').size;","module.exports = require('../impls/$slice/slice.js').slice;","module.exports = require('../impls/$some/some.js').some;","module.exports = require('../impls/$split-groups/split-groups.js').splitGroups;","module.exports = require('../impls/$split-on-any-seq/split-on-any-seq.js').splitOnAnySeq;","module.exports = require('../impls/$split-on-any/split-on-any.js').splitOnAny;","module.exports = require('../impls/$split-on-seq/split-on-seq.js').splitOnSeq;","module.exports = require('../impls/$split-on/split-on.js').splitOn;","module.exports = require('../impls/$split-when/split-when.js').splitWhen;","module.exports = require('../impls/$split/split.js').split;","module.exports = require('../impls/$spliterate-grouped/spliterate-grouped.js').spliterateGrouped;","module.exports = require('../impls/$spliterate/spliterate.js').spliterate;","module.exports = require('../impls/$starts-with-any-seq/starts-with-any-seq.js').startsWithAnySeq;","module.exports = require('../impls/$starts-with-any/starts-with-any.js').startsWithAny;","module.exports = require('../impls/$starts-with-seq/starts-with-seq.js').startsWithSeq;","module.exports = require('../impls/$starts-with/starts-with.js').startsWith;","module.exports = require('../impls/$str/str.js').str;","module.exports = require('../impls/string-from-async/string-from-async.js').stringFromAsync;","module.exports = require('../impls/string-from/string-from.js').stringFrom;","module.exports = require('../impls/$take-last-or/take-last-or.js').takeLastOr;","module.exports = require('../impls/$take-last/take-last.js').takeLast;","module.exports = require('../impls/$take-sorted/take-sorted.js').takeSorted;","module.exports = require('../impls/$take-while/take-while.js').takeWhile;","module.exports = require('../impls/$take/take.js').take;","module.exports = require('../impls/$tap/tap.js').tap;","module.exports = require('../impls/$to-array/to-array.js').toArray;","module.exports = require('../impls/$to-object/to-object.js').toObject;","module.exports = require('../impls/when/when.js').when;","module.exports = require('../impls/$window-ahead/window-ahead.js').windowAhead;","module.exports = require('../impls/$window-behind/window-behind.js').windowBehind;","module.exports = require('../impls/$window/window.js').window;","module.exports = require('../impls/wrap-entries/wrap-entries.js').wrapEntries;","module.exports = require('../impls/wrap-keys/wrap-keys.js').wrapKeys;","module.exports = require('../impls/wrap-values/wrap-values.js').wrapValues;","module.exports = require('../impls/$wrap/wrap.js').wrap;","module.exports = require('../impls/$zip-all/zip-all.js').zipAll;","module.exports = require('../impls/$zip/zip.js').zip;","/*\r\n Copyright 2013 Daniel Wirtz <dcode@dcode.io>\r\n Copyright 2009 The Closure Library Authors. All Rights Reserved.\r\n\r\n Licensed under the Apache License, Version 2.0 (the \"License\");\r\n you may not use this file except in compliance with the License.\r\n You may obtain a copy of the License at\r\n\r\n http://www.apache.org/licenses/LICENSE-2.0\r\n\r\n Unless required by applicable law or agreed to in writing, software\r\n distributed under the License is distributed on an \"AS-IS\" BASIS,\r\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n See the License for the specific language governing permissions and\r\n limitations under the License.\r\n */\r\n\r\n/**\r\n * @license long.js (c) 2013 Daniel Wirtz <dcode@dcode.io>\r\n * Released under the Apache License, Version 2.0\r\n * see: https://github.com/dcodeIO/long.js for details\r\n */\r\n(function(global, factory) {\r\n\r\n    /* AMD */ if (typeof define === 'function' && define[\"amd\"])\r\n        define([], factory);\r\n    /* CommonJS */ else if (typeof require === 'function' && typeof module === \"object\" && module && module[\"exports\"])\r\n        module[\"exports\"] = factory();\r\n    /* Global */ else\r\n        (global[\"dcodeIO\"] = global[\"dcodeIO\"] || {})[\"Long\"] = factory();\r\n\r\n})(this, function() {\r\n    \"use strict\";\r\n\r\n    /**\r\n     * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.\r\n     *  See the from* functions below for more convenient ways of constructing Longs.\r\n     * @exports Long\r\n     * @class A Long class for representing a 64 bit two's-complement integer value.\r\n     * @param {number} low The low (signed) 32 bits of the long\r\n     * @param {number} high The high (signed) 32 bits of the long\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @constructor\r\n     */\r\n    function Long(low, high, unsigned) {\r\n\r\n        /**\r\n         * The low 32 bits as a signed value.\r\n         * @type {number}\r\n         */\r\n        this.low = low | 0;\r\n\r\n        /**\r\n         * The high 32 bits as a signed value.\r\n         * @type {number}\r\n         */\r\n        this.high = high | 0;\r\n\r\n        /**\r\n         * Whether unsigned or not.\r\n         * @type {boolean}\r\n         */\r\n        this.unsigned = !!unsigned;\r\n    }\r\n\r\n    // The internal representation of a long is the two given signed, 32-bit values.\r\n    // We use 32-bit pieces because these are the size of integers on which\r\n    // Javascript performs bit-operations.  For operations like addition and\r\n    // multiplication, we split each number into 16 bit pieces, which can easily be\r\n    // multiplied within Javascript's floating-point representation without overflow\r\n    // or change in sign.\r\n    //\r\n    // In the algorithms below, we frequently reduce the negative case to the\r\n    // positive case by negating the input(s) and then post-processing the result.\r\n    // Note that we must ALWAYS check specially whether those values are MIN_VALUE\r\n    // (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as\r\n    // a positive number, it overflows back into a negative).  Not handling this\r\n    // case would often result in infinite recursion.\r\n    //\r\n    // Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*\r\n    // methods on which they depend.\r\n\r\n    /**\r\n     * An indicator used to reliably determine if an object is a Long or not.\r\n     * @type {boolean}\r\n     * @const\r\n     * @private\r\n     */\r\n    Long.prototype.__isLong__;\r\n\r\n    Object.defineProperty(Long.prototype, \"__isLong__\", {\r\n        value: true,\r\n        enumerable: false,\r\n        configurable: false\r\n    });\r\n\r\n    /**\r\n     * @function\r\n     * @param {*} obj Object\r\n     * @returns {boolean}\r\n     * @inner\r\n     */\r\n    function isLong(obj) {\r\n        return (obj && obj[\"__isLong__\"]) === true;\r\n    }\r\n\r\n    /**\r\n     * Tests if the specified object is a Long.\r\n     * @function\r\n     * @param {*} obj Object\r\n     * @returns {boolean}\r\n     */\r\n    Long.isLong = isLong;\r\n\r\n    /**\r\n     * A cache of the Long representations of small integer values.\r\n     * @type {!Object}\r\n     * @inner\r\n     */\r\n    var INT_CACHE = {};\r\n\r\n    /**\r\n     * A cache of the Long representations of small unsigned integer values.\r\n     * @type {!Object}\r\n     * @inner\r\n     */\r\n    var UINT_CACHE = {};\r\n\r\n    /**\r\n     * @param {number} value\r\n     * @param {boolean=} unsigned\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromInt(value, unsigned) {\r\n        var obj, cachedObj, cache;\r\n        if (unsigned) {\r\n            value >>>= 0;\r\n            if (cache = (0 <= value && value < 256)) {\r\n                cachedObj = UINT_CACHE[value];\r\n                if (cachedObj)\r\n                    return cachedObj;\r\n            }\r\n            obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true);\r\n            if (cache)\r\n                UINT_CACHE[value] = obj;\r\n            return obj;\r\n        } else {\r\n            value |= 0;\r\n            if (cache = (-128 <= value && value < 128)) {\r\n                cachedObj = INT_CACHE[value];\r\n                if (cachedObj)\r\n                    return cachedObj;\r\n            }\r\n            obj = fromBits(value, value < 0 ? -1 : 0, false);\r\n            if (cache)\r\n                INT_CACHE[value] = obj;\r\n            return obj;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representing the given 32 bit integer value.\r\n     * @function\r\n     * @param {number} value The 32 bit integer in question\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromInt = fromInt;\r\n\r\n    /**\r\n     * @param {number} value\r\n     * @param {boolean=} unsigned\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromNumber(value, unsigned) {\r\n        if (isNaN(value) || !isFinite(value))\r\n            return unsigned ? UZERO : ZERO;\r\n        if (unsigned) {\r\n            if (value < 0)\r\n                return UZERO;\r\n            if (value >= TWO_PWR_64_DBL)\r\n                return MAX_UNSIGNED_VALUE;\r\n        } else {\r\n            if (value <= -TWO_PWR_63_DBL)\r\n                return MIN_VALUE;\r\n            if (value + 1 >= TWO_PWR_63_DBL)\r\n                return MAX_VALUE;\r\n        }\r\n        if (value < 0)\r\n            return fromNumber(-value, unsigned).neg();\r\n        return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.\r\n     * @function\r\n     * @param {number} value The number in question\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromNumber = fromNumber;\r\n\r\n    /**\r\n     * @param {number} lowBits\r\n     * @param {number} highBits\r\n     * @param {boolean=} unsigned\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromBits(lowBits, highBits, unsigned) {\r\n        return new Long(lowBits, highBits, unsigned);\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is\r\n     *  assumed to use 32 bits.\r\n     * @function\r\n     * @param {number} lowBits The low 32 bits\r\n     * @param {number} highBits The high 32 bits\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromBits = fromBits;\r\n\r\n    /**\r\n     * @function\r\n     * @param {number} base\r\n     * @param {number} exponent\r\n     * @returns {number}\r\n     * @inner\r\n     */\r\n    var pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4)\r\n\r\n    /**\r\n     * @param {string} str\r\n     * @param {(boolean|number)=} unsigned\r\n     * @param {number=} radix\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromString(str, unsigned, radix) {\r\n        if (str.length === 0)\r\n            throw Error('empty string');\r\n        if (str === \"NaN\" || str === \"Infinity\" || str === \"+Infinity\" || str === \"-Infinity\")\r\n            return ZERO;\r\n        if (typeof unsigned === 'number') {\r\n            // For goog.math.long compatibility\r\n            radix = unsigned,\r\n            unsigned = false;\r\n        } else {\r\n            unsigned = !! unsigned;\r\n        }\r\n        radix = radix || 10;\r\n        if (radix < 2 || 36 < radix)\r\n            throw RangeError('radix');\r\n\r\n        var p;\r\n        if ((p = str.indexOf('-')) > 0)\r\n            throw Error('interior hyphen');\r\n        else if (p === 0) {\r\n            return fromString(str.substring(1), unsigned, radix).neg();\r\n        }\r\n\r\n        // Do several (8) digits each time through the loop, so as to\r\n        // minimize the calls to the very expensive emulated div.\r\n        var radixToPower = fromNumber(pow_dbl(radix, 8));\r\n\r\n        var result = ZERO;\r\n        for (var i = 0; i < str.length; i += 8) {\r\n            var size = Math.min(8, str.length - i),\r\n                value = parseInt(str.substring(i, i + size), radix);\r\n            if (size < 8) {\r\n                var power = fromNumber(pow_dbl(radix, size));\r\n                result = result.mul(power).add(fromNumber(value));\r\n            } else {\r\n                result = result.mul(radixToPower);\r\n                result = result.add(fromNumber(value));\r\n            }\r\n        }\r\n        result.unsigned = unsigned;\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representation of the given string, written using the specified radix.\r\n     * @function\r\n     * @param {string} str The textual representation of the Long\r\n     * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @param {number=} radix The radix in which the text is written (2-36), defaults to 10\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromString = fromString;\r\n\r\n    /**\r\n     * @function\r\n     * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromValue(val) {\r\n        if (val /* is compatible */ instanceof Long)\r\n            return val;\r\n        if (typeof val === 'number')\r\n            return fromNumber(val);\r\n        if (typeof val === 'string')\r\n            return fromString(val);\r\n        // Throws for non-objects, converts non-instanceof Long:\r\n        return fromBits(val.low, val.high, val.unsigned);\r\n    }\r\n\r\n    /**\r\n     * Converts the specified value to a Long.\r\n     * @function\r\n     * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value\r\n     * @returns {!Long}\r\n     */\r\n    Long.fromValue = fromValue;\r\n\r\n    // NOTE: the compiler should inline these constant values below and then remove these variables, so there should be\r\n    // no runtime penalty for these.\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_16_DBL = 1 << 16;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_24_DBL = 1 << 24;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var ZERO = fromInt(0);\r\n\r\n    /**\r\n     * Signed zero.\r\n     * @type {!Long}\r\n     */\r\n    Long.ZERO = ZERO;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var UZERO = fromInt(0, true);\r\n\r\n    /**\r\n     * Unsigned zero.\r\n     * @type {!Long}\r\n     */\r\n    Long.UZERO = UZERO;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var ONE = fromInt(1);\r\n\r\n    /**\r\n     * Signed one.\r\n     * @type {!Long}\r\n     */\r\n    Long.ONE = ONE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var UONE = fromInt(1, true);\r\n\r\n    /**\r\n     * Unsigned one.\r\n     * @type {!Long}\r\n     */\r\n    Long.UONE = UONE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var NEG_ONE = fromInt(-1);\r\n\r\n    /**\r\n     * Signed negative one.\r\n     * @type {!Long}\r\n     */\r\n    Long.NEG_ONE = NEG_ONE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var MAX_VALUE = fromBits(0xFFFFFFFF|0, 0x7FFFFFFF|0, false);\r\n\r\n    /**\r\n     * Maximum signed value.\r\n     * @type {!Long}\r\n     */\r\n    Long.MAX_VALUE = MAX_VALUE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF|0, 0xFFFFFFFF|0, true);\r\n\r\n    /**\r\n     * Maximum unsigned value.\r\n     * @type {!Long}\r\n     */\r\n    Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var MIN_VALUE = fromBits(0, 0x80000000|0, false);\r\n\r\n    /**\r\n     * Minimum signed value.\r\n     * @type {!Long}\r\n     */\r\n    Long.MIN_VALUE = MIN_VALUE;\r\n\r\n    /**\r\n     * @alias Long.prototype\r\n     * @inner\r\n     */\r\n    var LongPrototype = Long.prototype;\r\n\r\n    /**\r\n     * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\r\n     * @returns {number}\r\n     */\r\n    LongPrototype.toInt = function toInt() {\r\n        return this.unsigned ? this.low >>> 0 : this.low;\r\n    };\r\n\r\n    /**\r\n     * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).\r\n     * @returns {number}\r\n     */\r\n    LongPrototype.toNumber = function toNumber() {\r\n        if (this.unsigned)\r\n            return ((this.high >>> 0) * TWO_PWR_32_DBL) + (this.low >>> 0);\r\n        return this.high * TWO_PWR_32_DBL + (this.low >>> 0);\r\n    };\r\n\r\n    /**\r\n     * Converts the Long to a string written in the specified radix.\r\n     * @param {number=} radix Radix (2-36), defaults to 10\r\n     * @returns {string}\r\n     * @override\r\n     * @throws {RangeError} If `radix` is out of range\r\n     */\r\n    LongPrototype.toString = function toString(radix) {\r\n        radix = radix || 10;\r\n        if (radix < 2 || 36 < radix)\r\n            throw RangeError('radix');\r\n        if (this.isZero())\r\n            return '0';\r\n        if (this.isNegative()) { // Unsigned Longs are never negative\r\n            if (this.eq(MIN_VALUE)) {\r\n                // We need to change the Long value before it can be negated, so we remove\r\n                // the bottom-most digit in this base and then recurse to do the rest.\r\n                var radixLong = fromNumber(radix),\r\n                    div = this.div(radixLong),\r\n                    rem1 = div.mul(radixLong).sub(this);\r\n                return div.toString(radix) + rem1.toInt().toString(radix);\r\n            } else\r\n                return '-' + this.neg().toString(radix);\r\n        }\r\n\r\n        // Do several (6) digits each time through the loop, so as to\r\n        // minimize the calls to the very expensive emulated div.\r\n        var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned),\r\n            rem = this;\r\n        var result = '';\r\n        while (true) {\r\n            var remDiv = rem.div(radixToPower),\r\n                intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0,\r\n                digits = intval.toString(radix);\r\n            rem = remDiv;\r\n            if (rem.isZero())\r\n                return digits + result;\r\n            else {\r\n                while (digits.length < 6)\r\n                    digits = '0' + digits;\r\n                result = '' + digits + result;\r\n            }\r\n        }\r\n    };\r\n\r\n    /**\r\n     * Gets the high 32 bits as a signed integer.\r\n     * @returns {number} Signed high bits\r\n     */\r\n    LongPrototype.getHighBits = function getHighBits() {\r\n        return this.high;\r\n    };\r\n\r\n    /**\r\n     * Gets the high 32 bits as an unsigned integer.\r\n     * @returns {number} Unsigned high bits\r\n     */\r\n    LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {\r\n        return this.high >>> 0;\r\n    };\r\n\r\n    /**\r\n     * Gets the low 32 bits as a signed integer.\r\n     * @returns {number} Signed low bits\r\n     */\r\n    LongPrototype.getLowBits = function getLowBits() {\r\n        return this.low;\r\n    };\r\n\r\n    /**\r\n     * Gets the low 32 bits as an unsigned integer.\r\n     * @returns {number} Unsigned low bits\r\n     */\r\n    LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {\r\n        return this.low >>> 0;\r\n    };\r\n\r\n    /**\r\n     * Gets the number of bits needed to represent the absolute value of this Long.\r\n     * @returns {number}\r\n     */\r\n    LongPrototype.getNumBitsAbs = function getNumBitsAbs() {\r\n        if (this.isNegative()) // Unsigned Longs are never negative\r\n            return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();\r\n        var val = this.high != 0 ? this.high : this.low;\r\n        for (var bit = 31; bit > 0; bit--)\r\n            if ((val & (1 << bit)) != 0)\r\n                break;\r\n        return this.high != 0 ? bit + 33 : bit + 1;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value equals zero.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isZero = function isZero() {\r\n        return this.high === 0 && this.low === 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is negative.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isNegative = function isNegative() {\r\n        return !this.unsigned && this.high < 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is positive.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isPositive = function isPositive() {\r\n        return this.unsigned || this.high >= 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is odd.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isOdd = function isOdd() {\r\n        return (this.low & 1) === 1;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is even.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isEven = function isEven() {\r\n        return (this.low & 1) === 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value equals the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.equals = function equals(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        if (this.unsigned !== other.unsigned && (this.high >>> 31) === 1 && (other.high >>> 31) === 1)\r\n            return false;\r\n        return this.high === other.high && this.low === other.low;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.eq = LongPrototype.equals;\r\n\r\n    /**\r\n     * Tests if this Long's value differs from the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.notEquals = function notEquals(other) {\r\n        return !this.eq(/* validates */ other);\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.neq = LongPrototype.notEquals;\r\n\r\n    /**\r\n     * Tests if this Long's value is less than the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lessThan = function lessThan(other) {\r\n        return this.comp(/* validates */ other) < 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lt = LongPrototype.lessThan;\r\n\r\n    /**\r\n     * Tests if this Long's value is less than or equal the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {\r\n        return this.comp(/* validates */ other) <= 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lte = LongPrototype.lessThanOrEqual;\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.greaterThan = function greaterThan(other) {\r\n        return this.comp(/* validates */ other) > 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.gt = LongPrototype.greaterThan;\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than or equal the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {\r\n        return this.comp(/* validates */ other) >= 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.gte = LongPrototype.greaterThanOrEqual;\r\n\r\n    /**\r\n     * Compares this Long's value with the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {number} 0 if they are the same, 1 if the this is greater and -1\r\n     *  if the given one is greater\r\n     */\r\n    LongPrototype.compare = function compare(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        if (this.eq(other))\r\n            return 0;\r\n        var thisNeg = this.isNegative(),\r\n            otherNeg = other.isNegative();\r\n        if (thisNeg && !otherNeg)\r\n            return -1;\r\n        if (!thisNeg && otherNeg)\r\n            return 1;\r\n        // At this point the sign bits are the same\r\n        if (!this.unsigned)\r\n            return this.sub(other).isNegative() ? -1 : 1;\r\n        // Both are positive if at least one is unsigned\r\n        return (other.high >>> 0) > (this.high >>> 0) || (other.high === this.high && (other.low >>> 0) > (this.low >>> 0)) ? -1 : 1;\r\n    };\r\n\r\n    /**\r\n     * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {number} 0 if they are the same, 1 if the this is greater and -1\r\n     *  if the given one is greater\r\n     */\r\n    LongPrototype.comp = LongPrototype.compare;\r\n\r\n    /**\r\n     * Negates this Long's value.\r\n     * @returns {!Long} Negated Long\r\n     */\r\n    LongPrototype.negate = function negate() {\r\n        if (!this.unsigned && this.eq(MIN_VALUE))\r\n            return MIN_VALUE;\r\n        return this.not().add(ONE);\r\n    };\r\n\r\n    /**\r\n     * Negates this Long's value. This is an alias of {@link Long#negate}.\r\n     * @function\r\n     * @returns {!Long} Negated Long\r\n     */\r\n    LongPrototype.neg = LongPrototype.negate;\r\n\r\n    /**\r\n     * Returns the sum of this and the specified Long.\r\n     * @param {!Long|number|string} addend Addend\r\n     * @returns {!Long} Sum\r\n     */\r\n    LongPrototype.add = function add(addend) {\r\n        if (!isLong(addend))\r\n            addend = fromValue(addend);\r\n\r\n        // Divide each number into 4 chunks of 16 bits, and then sum the chunks.\r\n\r\n        var a48 = this.high >>> 16;\r\n        var a32 = this.high & 0xFFFF;\r\n        var a16 = this.low >>> 16;\r\n        var a00 = this.low & 0xFFFF;\r\n\r\n        var b48 = addend.high >>> 16;\r\n        var b32 = addend.high & 0xFFFF;\r\n        var b16 = addend.low >>> 16;\r\n        var b00 = addend.low & 0xFFFF;\r\n\r\n        var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\r\n        c00 += a00 + b00;\r\n        c16 += c00 >>> 16;\r\n        c00 &= 0xFFFF;\r\n        c16 += a16 + b16;\r\n        c32 += c16 >>> 16;\r\n        c16 &= 0xFFFF;\r\n        c32 += a32 + b32;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c48 += a48 + b48;\r\n        c48 &= 0xFFFF;\r\n        return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the difference of this and the specified Long.\r\n     * @param {!Long|number|string} subtrahend Subtrahend\r\n     * @returns {!Long} Difference\r\n     */\r\n    LongPrototype.subtract = function subtract(subtrahend) {\r\n        if (!isLong(subtrahend))\r\n            subtrahend = fromValue(subtrahend);\r\n        return this.add(subtrahend.neg());\r\n    };\r\n\r\n    /**\r\n     * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.\r\n     * @function\r\n     * @param {!Long|number|string} subtrahend Subtrahend\r\n     * @returns {!Long} Difference\r\n     */\r\n    LongPrototype.sub = LongPrototype.subtract;\r\n\r\n    /**\r\n     * Returns the product of this and the specified Long.\r\n     * @param {!Long|number|string} multiplier Multiplier\r\n     * @returns {!Long} Product\r\n     */\r\n    LongPrototype.multiply = function multiply(multiplier) {\r\n        if (this.isZero())\r\n            return ZERO;\r\n        if (!isLong(multiplier))\r\n            multiplier = fromValue(multiplier);\r\n        if (multiplier.isZero())\r\n            return ZERO;\r\n        if (this.eq(MIN_VALUE))\r\n            return multiplier.isOdd() ? MIN_VALUE : ZERO;\r\n        if (multiplier.eq(MIN_VALUE))\r\n            return this.isOdd() ? MIN_VALUE : ZERO;\r\n\r\n        if (this.isNegative()) {\r\n            if (multiplier.isNegative())\r\n                return this.neg().mul(multiplier.neg());\r\n            else\r\n                return this.neg().mul(multiplier).neg();\r\n        } else if (multiplier.isNegative())\r\n            return this.mul(multiplier.neg()).neg();\r\n\r\n        // If both longs are small, use float multiplication\r\n        if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))\r\n            return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);\r\n\r\n        // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.\r\n        // We can skip products that would overflow.\r\n\r\n        var a48 = this.high >>> 16;\r\n        var a32 = this.high & 0xFFFF;\r\n        var a16 = this.low >>> 16;\r\n        var a00 = this.low & 0xFFFF;\r\n\r\n        var b48 = multiplier.high >>> 16;\r\n        var b32 = multiplier.high & 0xFFFF;\r\n        var b16 = multiplier.low >>> 16;\r\n        var b00 = multiplier.low & 0xFFFF;\r\n\r\n        var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\r\n        c00 += a00 * b00;\r\n        c16 += c00 >>> 16;\r\n        c00 &= 0xFFFF;\r\n        c16 += a16 * b00;\r\n        c32 += c16 >>> 16;\r\n        c16 &= 0xFFFF;\r\n        c16 += a00 * b16;\r\n        c32 += c16 >>> 16;\r\n        c16 &= 0xFFFF;\r\n        c32 += a32 * b00;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c32 += a16 * b16;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c32 += a00 * b32;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;\r\n        c48 &= 0xFFFF;\r\n        return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.\r\n     * @function\r\n     * @param {!Long|number|string} multiplier Multiplier\r\n     * @returns {!Long} Product\r\n     */\r\n    LongPrototype.mul = LongPrototype.multiply;\r\n\r\n    /**\r\n     * Returns this Long divided by the specified. The result is signed if this Long is signed or\r\n     *  unsigned if this Long is unsigned.\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Quotient\r\n     */\r\n    LongPrototype.divide = function divide(divisor) {\r\n        if (!isLong(divisor))\r\n            divisor = fromValue(divisor);\r\n        if (divisor.isZero())\r\n            throw Error('division by zero');\r\n        if (this.isZero())\r\n            return this.unsigned ? UZERO : ZERO;\r\n        var approx, rem, res;\r\n        if (!this.unsigned) {\r\n            // This section is only relevant for signed longs and is derived from the\r\n            // closure library as a whole.\r\n            if (this.eq(MIN_VALUE)) {\r\n                if (divisor.eq(ONE) || divisor.eq(NEG_ONE))\r\n                    return MIN_VALUE;  // recall that -MIN_VALUE == MIN_VALUE\r\n                else if (divisor.eq(MIN_VALUE))\r\n                    return ONE;\r\n                else {\r\n                    // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.\r\n                    var halfThis = this.shr(1);\r\n                    approx = halfThis.div(divisor).shl(1);\r\n                    if (approx.eq(ZERO)) {\r\n                        return divisor.isNegative() ? ONE : NEG_ONE;\r\n                    } else {\r\n                        rem = this.sub(divisor.mul(approx));\r\n                        res = approx.add(rem.div(divisor));\r\n                        return res;\r\n                    }\r\n                }\r\n            } else if (divisor.eq(MIN_VALUE))\r\n                return this.unsigned ? UZERO : ZERO;\r\n            if (this.isNegative()) {\r\n                if (divisor.isNegative())\r\n                    return this.neg().div(divisor.neg());\r\n                return this.neg().div(divisor).neg();\r\n            } else if (divisor.isNegative())\r\n                return this.div(divisor.neg()).neg();\r\n            res = ZERO;\r\n        } else {\r\n            // The algorithm below has not been made for unsigned longs. It's therefore\r\n            // required to take special care of the MSB prior to running it.\r\n            if (!divisor.unsigned)\r\n                divisor = divisor.toUnsigned();\r\n            if (divisor.gt(this))\r\n                return UZERO;\r\n            if (divisor.gt(this.shru(1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true\r\n                return UONE;\r\n            res = UZERO;\r\n        }\r\n\r\n        // Repeat the following until the remainder is less than other:  find a\r\n        // floating-point that approximates remainder / other *from below*, add this\r\n        // into the result, and subtract it from the remainder.  It is critical that\r\n        // the approximate value is less than or equal to the real value so that the\r\n        // remainder never becomes negative.\r\n        rem = this;\r\n        while (rem.gte(divisor)) {\r\n            // Approximate the result of division. This may be a little greater or\r\n            // smaller than the actual value.\r\n            approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));\r\n\r\n            // We will tweak the approximate result by changing it in the 48-th digit or\r\n            // the smallest non-fractional digit, whichever is larger.\r\n            var log2 = Math.ceil(Math.log(approx) / Math.LN2),\r\n                delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48),\r\n\r\n            // Decrease the approximation until it is smaller than the remainder.  Note\r\n            // that if it is too large, the product overflows and is negative.\r\n                approxRes = fromNumber(approx),\r\n                approxRem = approxRes.mul(divisor);\r\n            while (approxRem.isNegative() || approxRem.gt(rem)) {\r\n                approx -= delta;\r\n                approxRes = fromNumber(approx, this.unsigned);\r\n                approxRem = approxRes.mul(divisor);\r\n            }\r\n\r\n            // We know the answer can't be zero... and actually, zero would cause\r\n            // infinite recursion since we would make no progress.\r\n            if (approxRes.isZero())\r\n                approxRes = ONE;\r\n\r\n            res = res.add(approxRes);\r\n            rem = rem.sub(approxRem);\r\n        }\r\n        return res;\r\n    };\r\n\r\n    /**\r\n     * Returns this Long divided by the specified. This is an alias of {@link Long#divide}.\r\n     * @function\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Quotient\r\n     */\r\n    LongPrototype.div = LongPrototype.divide;\r\n\r\n    /**\r\n     * Returns this Long modulo the specified.\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Remainder\r\n     */\r\n    LongPrototype.modulo = function modulo(divisor) {\r\n        if (!isLong(divisor))\r\n            divisor = fromValue(divisor);\r\n        return this.sub(this.div(divisor).mul(divisor));\r\n    };\r\n\r\n    /**\r\n     * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\r\n     * @function\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Remainder\r\n     */\r\n    LongPrototype.mod = LongPrototype.modulo;\r\n\r\n    /**\r\n     * Returns the bitwise NOT of this Long.\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.not = function not() {\r\n        return fromBits(~this.low, ~this.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the bitwise AND of this Long and the specified.\r\n     * @param {!Long|number|string} other Other Long\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.and = function and(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        return fromBits(this.low & other.low, this.high & other.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the bitwise OR of this Long and the specified.\r\n     * @param {!Long|number|string} other Other Long\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.or = function or(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        return fromBits(this.low | other.low, this.high | other.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the bitwise XOR of this Long and the given one.\r\n     * @param {!Long|number|string} other Other Long\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.xor = function xor(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits shifted to the left by the given amount.\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shiftLeft = function shiftLeft(numBits) {\r\n        if (isLong(numBits))\r\n            numBits = numBits.toInt();\r\n        if ((numBits &= 63) === 0)\r\n            return this;\r\n        else if (numBits < 32)\r\n            return fromBits(this.low << numBits, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned);\r\n        else\r\n            return fromBits(0, this.low << (numBits - 32), this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.\r\n     * @function\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shl = LongPrototype.shiftLeft;\r\n\r\n    /**\r\n     * Returns this Long with bits arithmetically shifted to the right by the given amount.\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shiftRight = function shiftRight(numBits) {\r\n        if (isLong(numBits))\r\n            numBits = numBits.toInt();\r\n        if ((numBits &= 63) === 0)\r\n            return this;\r\n        else if (numBits < 32)\r\n            return fromBits((this.low >>> numBits) | (this.high << (32 - numBits)), this.high >> numBits, this.unsigned);\r\n        else\r\n            return fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.\r\n     * @function\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shr = LongPrototype.shiftRight;\r\n\r\n    /**\r\n     * Returns this Long with bits logically shifted to the right by the given amount.\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {\r\n        if (isLong(numBits))\r\n            numBits = numBits.toInt();\r\n        numBits &= 63;\r\n        if (numBits === 0)\r\n            return this;\r\n        else {\r\n            var high = this.high;\r\n            if (numBits < 32) {\r\n                var low = this.low;\r\n                return fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, this.unsigned);\r\n            } else if (numBits === 32)\r\n                return fromBits(high, 0, this.unsigned);\r\n            else\r\n                return fromBits(high >>> (numBits - 32), 0, this.unsigned);\r\n        }\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\r\n     * @function\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shru = LongPrototype.shiftRightUnsigned;\r\n\r\n    /**\r\n     * Converts this Long to signed.\r\n     * @returns {!Long} Signed long\r\n     */\r\n    LongPrototype.toSigned = function toSigned() {\r\n        if (!this.unsigned)\r\n            return this;\r\n        return fromBits(this.low, this.high, false);\r\n    };\r\n\r\n    /**\r\n     * Converts this Long to unsigned.\r\n     * @returns {!Long} Unsigned long\r\n     */\r\n    LongPrototype.toUnsigned = function toUnsigned() {\r\n        if (this.unsigned)\r\n            return this;\r\n        return fromBits(this.low, this.high, true);\r\n    };\r\n\r\n    /**\r\n     * Converts this Long to its byte representation.\r\n     * @param {boolean=} le Whether little or big endian, defaults to big endian\r\n     * @returns {!Array.<number>} Byte representation\r\n     */\r\n    LongPrototype.toBytes = function(le) {\r\n        return le ? this.toBytesLE() : this.toBytesBE();\r\n    }\r\n\r\n    /**\r\n     * Converts this Long to its little endian byte representation.\r\n     * @returns {!Array.<number>} Little endian byte representation\r\n     */\r\n    LongPrototype.toBytesLE = function() {\r\n        var hi = this.high,\r\n            lo = this.low;\r\n        return [\r\n             lo         & 0xff,\r\n            (lo >>>  8) & 0xff,\r\n            (lo >>> 16) & 0xff,\r\n            (lo >>> 24) & 0xff,\r\n             hi         & 0xff,\r\n            (hi >>>  8) & 0xff,\r\n            (hi >>> 16) & 0xff,\r\n            (hi >>> 24) & 0xff\r\n        ];\r\n    }\r\n\r\n    /**\r\n     * Converts this Long to its big endian byte representation.\r\n     * @returns {!Array.<number>} Big endian byte representation\r\n     */\r\n    LongPrototype.toBytesBE = function() {\r\n        var hi = this.high,\r\n            lo = this.low;\r\n        return [\r\n            (hi >>> 24) & 0xff,\r\n            (hi >>> 16) & 0xff,\r\n            (hi >>>  8) & 0xff,\r\n             hi         & 0xff,\r\n            (lo >>> 24) & 0xff,\r\n            (lo >>> 16) & 0xff,\r\n            (lo >>>  8) & 0xff,\r\n             lo         & 0xff\r\n        ];\r\n    }\r\n\r\n    return Long;\r\n});\r\n","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","// minimal library entry point.\n\n\"use strict\";\nmodule.exports = require(\"./src/index-minimal\");\n","\"use strict\";\nvar protobuf = exports;\n\n/**\n * Build type, one of `\"full\"`, `\"light\"` or `\"minimal\"`.\n * @name build\n * @type {string}\n * @const\n */\nprotobuf.build = \"minimal\";\n\n// Serialization\nprotobuf.Writer       = require(\"./writer\");\nprotobuf.BufferWriter = require(\"./writer_buffer\");\nprotobuf.Reader       = require(\"./reader\");\nprotobuf.BufferReader = require(\"./reader_buffer\");\n\n// Utility\nprotobuf.util         = require(\"./util/minimal\");\nprotobuf.rpc          = require(\"./rpc\");\nprotobuf.roots        = require(\"./roots\");\nprotobuf.configure    = configure;\n\n/* istanbul ignore next */\n/**\n * Reconfigures the library according to the environment.\n * @returns {undefined}\n */\nfunction configure() {\n    protobuf.util._configure();\n    protobuf.Writer._configure(protobuf.BufferWriter);\n    protobuf.Reader._configure(protobuf.BufferReader);\n}\n\n// Set up buffer utility according to the environment\nconfigure();\n","\"use strict\";\nmodule.exports = Reader;\n\nvar util      = require(\"./util/minimal\");\n\nvar BufferReader; // cyclic\n\nvar LongBits  = util.LongBits,\n    utf8      = util.utf8;\n\n/* istanbul ignore next */\nfunction indexOutOfRange(reader, writeLength) {\n    return RangeError(\"index out of range: \" + reader.pos + \" + \" + (writeLength || 1) + \" > \" + reader.len);\n}\n\n/**\n * Constructs a new reader instance using the specified buffer.\n * @classdesc Wire format reader using `Uint8Array` if available, otherwise `Array`.\n * @constructor\n * @param {Uint8Array} buffer Buffer to read from\n */\nfunction Reader(buffer) {\n\n    /**\n     * Read buffer.\n     * @type {Uint8Array}\n     */\n    this.buf = buffer;\n\n    /**\n     * Read buffer position.\n     * @type {number}\n     */\n    this.pos = 0;\n\n    /**\n     * Read buffer length.\n     * @type {number}\n     */\n    this.len = buffer.length;\n}\n\nvar create_array = typeof Uint8Array !== \"undefined\"\n    ? function create_typed_array(buffer) {\n        if (buffer instanceof Uint8Array || Array.isArray(buffer))\n            return new Reader(buffer);\n        throw Error(\"illegal buffer\");\n    }\n    /* istanbul ignore next */\n    : function create_array(buffer) {\n        if (Array.isArray(buffer))\n            return new Reader(buffer);\n        throw Error(\"illegal buffer\");\n    };\n\nvar create = function create() {\n    return util.Buffer\n        ? function create_buffer_setup(buffer) {\n            return (Reader.create = function create_buffer(buffer) {\n                return util.Buffer.isBuffer(buffer)\n                    ? new BufferReader(buffer)\n                    /* istanbul ignore next */\n                    : create_array(buffer);\n            })(buffer);\n        }\n        /* istanbul ignore next */\n        : create_array;\n};\n\n/**\n * Creates a new reader using the specified buffer.\n * @function\n * @param {Uint8Array|Buffer} buffer Buffer to read from\n * @returns {Reader|BufferReader} A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}\n * @throws {Error} If `buffer` is not a valid buffer\n */\nReader.create = create();\n\nReader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */ util.Array.prototype.slice;\n\n/**\n * Reads a varint as an unsigned 32 bit value.\n * @function\n * @returns {number} Value read\n */\nReader.prototype.uint32 = (function read_uint32_setup() {\n    var value = 4294967295; // optimizer type-hint, tends to deopt otherwise (?!)\n    return function read_uint32() {\n        value = (         this.buf[this.pos] & 127       ) >>> 0; if (this.buf[this.pos++] < 128) return value;\n        value = (value | (this.buf[this.pos] & 127) <<  7) >>> 0; if (this.buf[this.pos++] < 128) return value;\n        value = (value | (this.buf[this.pos] & 127) << 14) >>> 0; if (this.buf[this.pos++] < 128) return value;\n        value = (value | (this.buf[this.pos] & 127) << 21) >>> 0; if (this.buf[this.pos++] < 128) return value;\n        value = (value | (this.buf[this.pos] &  15) << 28) >>> 0; if (this.buf[this.pos++] < 128) return value;\n\n        /* istanbul ignore if */\n        if ((this.pos += 5) > this.len) {\n            this.pos = this.len;\n            throw indexOutOfRange(this, 10);\n        }\n        return value;\n    };\n})();\n\n/**\n * Reads a varint as a signed 32 bit value.\n * @returns {number} Value read\n */\nReader.prototype.int32 = function read_int32() {\n    return this.uint32() | 0;\n};\n\n/**\n * Reads a zig-zag encoded varint as a signed 32 bit value.\n * @returns {number} Value read\n */\nReader.prototype.sint32 = function read_sint32() {\n    var value = this.uint32();\n    return value >>> 1 ^ -(value & 1) | 0;\n};\n\n/* eslint-disable no-invalid-this */\n\nfunction readLongVarint() {\n    // tends to deopt with local vars for octet etc.\n    var bits = new LongBits(0, 0);\n    var i = 0;\n    if (this.len - this.pos > 4) { // fast route (lo)\n        for (; i < 4; ++i) {\n            // 1st..4th\n            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;\n            if (this.buf[this.pos++] < 128)\n                return bits;\n        }\n        // 5th\n        bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;\n        bits.hi = (bits.hi | (this.buf[this.pos] & 127) >>  4) >>> 0;\n        if (this.buf[this.pos++] < 128)\n            return bits;\n        i = 0;\n    } else {\n        for (; i < 3; ++i) {\n            /* istanbul ignore if */\n            if (this.pos >= this.len)\n                throw indexOutOfRange(this);\n            // 1st..3th\n            bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;\n            if (this.buf[this.pos++] < 128)\n                return bits;\n        }\n        // 4th\n        bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;\n        return bits;\n    }\n    if (this.len - this.pos > 4) { // fast route (hi)\n        for (; i < 5; ++i) {\n            // 6th..10th\n            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;\n            if (this.buf[this.pos++] < 128)\n                return bits;\n        }\n    } else {\n        for (; i < 5; ++i) {\n            /* istanbul ignore if */\n            if (this.pos >= this.len)\n                throw indexOutOfRange(this);\n            // 6th..10th\n            bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;\n            if (this.buf[this.pos++] < 128)\n                return bits;\n        }\n    }\n    /* istanbul ignore next */\n    throw Error(\"invalid varint encoding\");\n}\n\n/* eslint-enable no-invalid-this */\n\n/**\n * Reads a varint as a signed 64 bit value.\n * @name Reader#int64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads a varint as an unsigned 64 bit value.\n * @name Reader#uint64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads a zig-zag encoded varint as a signed 64 bit value.\n * @name Reader#sint64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads a varint as a boolean.\n * @returns {boolean} Value read\n */\nReader.prototype.bool = function read_bool() {\n    return this.uint32() !== 0;\n};\n\nfunction readFixed32_end(buf, end) { // note that this uses `end`, not `pos`\n    return (buf[end - 4]\n          | buf[end - 3] << 8\n          | buf[end - 2] << 16\n          | buf[end - 1] << 24) >>> 0;\n}\n\n/**\n * Reads fixed 32 bits as an unsigned 32 bit integer.\n * @returns {number} Value read\n */\nReader.prototype.fixed32 = function read_fixed32() {\n\n    /* istanbul ignore if */\n    if (this.pos + 4 > this.len)\n        throw indexOutOfRange(this, 4);\n\n    return readFixed32_end(this.buf, this.pos += 4);\n};\n\n/**\n * Reads fixed 32 bits as a signed 32 bit integer.\n * @returns {number} Value read\n */\nReader.prototype.sfixed32 = function read_sfixed32() {\n\n    /* istanbul ignore if */\n    if (this.pos + 4 > this.len)\n        throw indexOutOfRange(this, 4);\n\n    return readFixed32_end(this.buf, this.pos += 4) | 0;\n};\n\n/* eslint-disable no-invalid-this */\n\nfunction readFixed64(/* this: Reader */) {\n\n    /* istanbul ignore if */\n    if (this.pos + 8 > this.len)\n        throw indexOutOfRange(this, 8);\n\n    return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));\n}\n\n/* eslint-enable no-invalid-this */\n\n/**\n * Reads fixed 64 bits.\n * @name Reader#fixed64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads zig-zag encoded fixed 64 bits.\n * @name Reader#sfixed64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads a float (32 bit) as a number.\n * @function\n * @returns {number} Value read\n */\nReader.prototype.float = function read_float() {\n\n    /* istanbul ignore if */\n    if (this.pos + 4 > this.len)\n        throw indexOutOfRange(this, 4);\n\n    var value = util.float.readFloatLE(this.buf, this.pos);\n    this.pos += 4;\n    return value;\n};\n\n/**\n * Reads a double (64 bit float) as a number.\n * @function\n * @returns {number} Value read\n */\nReader.prototype.double = function read_double() {\n\n    /* istanbul ignore if */\n    if (this.pos + 8 > this.len)\n        throw indexOutOfRange(this, 4);\n\n    var value = util.float.readDoubleLE(this.buf, this.pos);\n    this.pos += 8;\n    return value;\n};\n\n/**\n * Reads a sequence of bytes preceeded by its length as a varint.\n * @returns {Uint8Array} Value read\n */\nReader.prototype.bytes = function read_bytes() {\n    var length = this.uint32(),\n        start  = this.pos,\n        end    = this.pos + length;\n\n    /* istanbul ignore if */\n    if (end > this.len)\n        throw indexOutOfRange(this, length);\n\n    this.pos += length;\n    if (Array.isArray(this.buf)) // plain array\n        return this.buf.slice(start, end);\n    return start === end // fix for IE 10/Win8 and others' subarray returning array of size 1\n        ? new this.buf.constructor(0)\n        : this._slice.call(this.buf, start, end);\n};\n\n/**\n * Reads a string preceeded by its byte length as a varint.\n * @returns {string} Value read\n */\nReader.prototype.string = function read_string() {\n    var bytes = this.bytes();\n    return utf8.read(bytes, 0, bytes.length);\n};\n\n/**\n * Skips the specified number of bytes if specified, otherwise skips a varint.\n * @param {number} [length] Length if known, otherwise a varint is assumed\n * @returns {Reader} `this`\n */\nReader.prototype.skip = function skip(length) {\n    if (typeof length === \"number\") {\n        /* istanbul ignore if */\n        if (this.pos + length > this.len)\n            throw indexOutOfRange(this, length);\n        this.pos += length;\n    } else {\n        do {\n            /* istanbul ignore if */\n            if (this.pos >= this.len)\n                throw indexOutOfRange(this);\n        } while (this.buf[this.pos++] & 128);\n    }\n    return this;\n};\n\n/**\n * Skips the next element of the specified wire type.\n * @param {number} wireType Wire type received\n * @returns {Reader} `this`\n */\nReader.prototype.skipType = function(wireType) {\n    switch (wireType) {\n        case 0:\n            this.skip();\n            break;\n        case 1:\n            this.skip(8);\n            break;\n        case 2:\n            this.skip(this.uint32());\n            break;\n        case 3:\n            while ((wireType = this.uint32() & 7) !== 4) {\n                this.skipType(wireType);\n            }\n            break;\n        case 5:\n            this.skip(4);\n            break;\n\n        /* istanbul ignore next */\n        default:\n            throw Error(\"invalid wire type \" + wireType + \" at offset \" + this.pos);\n    }\n    return this;\n};\n\nReader._configure = function(BufferReader_) {\n    BufferReader = BufferReader_;\n    Reader.create = create();\n    BufferReader._configure();\n\n    var fn = util.Long ? \"toLong\" : /* istanbul ignore next */ \"toNumber\";\n    util.merge(Reader.prototype, {\n\n        int64: function read_int64() {\n            return readLongVarint.call(this)[fn](false);\n        },\n\n        uint64: function read_uint64() {\n            return readLongVarint.call(this)[fn](true);\n        },\n\n        sint64: function read_sint64() {\n            return readLongVarint.call(this).zzDecode()[fn](false);\n        },\n\n        fixed64: function read_fixed64() {\n            return readFixed64.call(this)[fn](true);\n        },\n\n        sfixed64: function read_sfixed64() {\n            return readFixed64.call(this)[fn](false);\n        }\n\n    });\n};\n","\"use strict\";\nmodule.exports = BufferReader;\n\n// extends Reader\nvar Reader = require(\"./reader\");\n(BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;\n\nvar util = require(\"./util/minimal\");\n\n/**\n * Constructs a new buffer reader instance.\n * @classdesc Wire format reader using node buffers.\n * @extends Reader\n * @constructor\n * @param {Buffer} buffer Buffer to read from\n */\nfunction BufferReader(buffer) {\n    Reader.call(this, buffer);\n\n    /**\n     * Read buffer.\n     * @name BufferReader#buf\n     * @type {Buffer}\n     */\n}\n\nBufferReader._configure = function () {\n    /* istanbul ignore else */\n    if (util.Buffer)\n        BufferReader.prototype._slice = util.Buffer.prototype.slice;\n};\n\n\n/**\n * @override\n */\nBufferReader.prototype.string = function read_string_buffer() {\n    var len = this.uint32(); // modifies pos\n    return this.buf.utf8Slice\n        ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len))\n        : this.buf.toString(\"utf-8\", this.pos, this.pos = Math.min(this.pos + len, this.len));\n};\n\n/**\n * Reads a sequence of bytes preceeded by its length as a varint.\n * @name BufferReader#bytes\n * @function\n * @returns {Buffer} Value read\n */\n\nBufferReader._configure();\n","\"use strict\";\nmodule.exports = {};\n\n/**\n * Named roots.\n * This is where pbjs stores generated structures (the option `-r, --root` specifies a name).\n * Can also be used manually to make roots available accross modules.\n * @name roots\n * @type {Object.<string,Root>}\n * @example\n * // pbjs -r myroot -o compiled.js ...\n *\n * // in another module:\n * require(\"./compiled.js\");\n *\n * // in any subsequent module:\n * var root = protobuf.roots[\"myroot\"];\n */\n","\"use strict\";\n\n/**\n * Streaming RPC helpers.\n * @namespace\n */\nvar rpc = exports;\n\n/**\n * RPC implementation passed to {@link Service#create} performing a service request on network level, i.e. by utilizing http requests or websockets.\n * @typedef RPCImpl\n * @type {function}\n * @param {Method|rpc.ServiceMethod<Message<{}>,Message<{}>>} method Reflected or static method being called\n * @param {Uint8Array} requestData Request data\n * @param {RPCImplCallback} callback Callback function\n * @returns {undefined}\n * @example\n * function rpcImpl(method, requestData, callback) {\n *     if (protobuf.util.lcFirst(method.name) !== \"myMethod\") // compatible with static code\n *         throw Error(\"no such method\");\n *     asynchronouslyObtainAResponse(requestData, function(err, responseData) {\n *         callback(err, responseData);\n *     });\n * }\n */\n\n/**\n * Node-style callback as used by {@link RPCImpl}.\n * @typedef RPCImplCallback\n * @type {function}\n * @param {Error|null} error Error, if any, otherwise `null`\n * @param {Uint8Array|null} [response] Response data or `null` to signal end of stream, if there hasn't been an error\n * @returns {undefined}\n */\n\nrpc.Service = require(\"./rpc/service\");\n","\"use strict\";\nmodule.exports = Service;\n\nvar util = require(\"../util/minimal\");\n\n// Extends EventEmitter\n(Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;\n\n/**\n * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.\n *\n * Differs from {@link RPCImplCallback} in that it is an actual callback of a service method which may not return `response = null`.\n * @typedef rpc.ServiceMethodCallback\n * @template TRes extends Message<TRes>\n * @type {function}\n * @param {Error|null} error Error, if any\n * @param {TRes} [response] Response message\n * @returns {undefined}\n */\n\n/**\n * A service method part of a {@link rpc.Service} as created by {@link Service.create}.\n * @typedef rpc.ServiceMethod\n * @template TReq extends Message<TReq>\n * @template TRes extends Message<TRes>\n * @type {function}\n * @param {TReq|Properties<TReq>} request Request message or plain object\n * @param {rpc.ServiceMethodCallback<TRes>} [callback] Node-style callback called with the error, if any, and the response message\n * @returns {Promise<Message<TRes>>} Promise if `callback` has been omitted, otherwise `undefined`\n */\n\n/**\n * Constructs a new RPC service instance.\n * @classdesc An RPC service as returned by {@link Service#create}.\n * @exports rpc.Service\n * @extends util.EventEmitter\n * @constructor\n * @param {RPCImpl} rpcImpl RPC implementation\n * @param {boolean} [requestDelimited=false] Whether requests are length-delimited\n * @param {boolean} [responseDelimited=false] Whether responses are length-delimited\n */\nfunction Service(rpcImpl, requestDelimited, responseDelimited) {\n\n    if (typeof rpcImpl !== \"function\")\n        throw TypeError(\"rpcImpl must be a function\");\n\n    util.EventEmitter.call(this);\n\n    /**\n     * RPC implementation. Becomes `null` once the service is ended.\n     * @type {RPCImpl|null}\n     */\n    this.rpcImpl = rpcImpl;\n\n    /**\n     * Whether requests are length-delimited.\n     * @type {boolean}\n     */\n    this.requestDelimited = Boolean(requestDelimited);\n\n    /**\n     * Whether responses are length-delimited.\n     * @type {boolean}\n     */\n    this.responseDelimited = Boolean(responseDelimited);\n}\n\n/**\n * Calls a service method through {@link rpc.Service#rpcImpl|rpcImpl}.\n * @param {Method|rpc.ServiceMethod<TReq,TRes>} method Reflected or static method\n * @param {Constructor<TReq>} requestCtor Request constructor\n * @param {Constructor<TRes>} responseCtor Response constructor\n * @param {TReq|Properties<TReq>} request Request message or plain object\n * @param {rpc.ServiceMethodCallback<TRes>} callback Service callback\n * @returns {undefined}\n * @template TReq extends Message<TReq>\n * @template TRes extends Message<TRes>\n */\nService.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {\n\n    if (!request)\n        throw TypeError(\"request must be specified\");\n\n    var self = this;\n    if (!callback)\n        return util.asPromise(rpcCall, self, method, requestCtor, responseCtor, request);\n\n    if (!self.rpcImpl) {\n        setTimeout(function() { callback(Error(\"already ended\")); }, 0);\n        return undefined;\n    }\n\n    try {\n        return self.rpcImpl(\n            method,\n            requestCtor[self.requestDelimited ? \"encodeDelimited\" : \"encode\"](request).finish(),\n            function rpcCallback(err, response) {\n\n                if (err) {\n                    self.emit(\"error\", err, method);\n                    return callback(err);\n                }\n\n                if (response === null) {\n                    self.end(/* endedByRPC */ true);\n                    return undefined;\n                }\n\n                if (!(response instanceof responseCtor)) {\n                    try {\n                        response = responseCtor[self.responseDelimited ? \"decodeDelimited\" : \"decode\"](response);\n                    } catch (err) {\n                        self.emit(\"error\", err, method);\n                        return callback(err);\n                    }\n                }\n\n                self.emit(\"data\", response, method);\n                return callback(null, response);\n            }\n        );\n    } catch (err) {\n        self.emit(\"error\", err, method);\n        setTimeout(function() { callback(err); }, 0);\n        return undefined;\n    }\n};\n\n/**\n * Ends this service and emits the `end` event.\n * @param {boolean} [endedByRPC=false] Whether the service has been ended by the RPC implementation.\n * @returns {rpc.Service} `this`\n */\nService.prototype.end = function end(endedByRPC) {\n    if (this.rpcImpl) {\n        if (!endedByRPC) // signal end to rpcImpl\n            this.rpcImpl(null, null, null);\n        this.rpcImpl = null;\n        this.emit(\"end\").off();\n    }\n    return this;\n};\n","\"use strict\";\nmodule.exports = LongBits;\n\nvar util = require(\"../util/minimal\");\n\n/**\n * Constructs new long bits.\n * @classdesc Helper class for working with the low and high bits of a 64 bit value.\n * @memberof util\n * @constructor\n * @param {number} lo Low 32 bits, unsigned\n * @param {number} hi High 32 bits, unsigned\n */\nfunction LongBits(lo, hi) {\n\n    // note that the casts below are theoretically unnecessary as of today, but older statically\n    // generated converter code might still call the ctor with signed 32bits. kept for compat.\n\n    /**\n     * Low bits.\n     * @type {number}\n     */\n    this.lo = lo >>> 0;\n\n    /**\n     * High bits.\n     * @type {number}\n     */\n    this.hi = hi >>> 0;\n}\n\n/**\n * Zero bits.\n * @memberof util.LongBits\n * @type {util.LongBits}\n */\nvar zero = LongBits.zero = new LongBits(0, 0);\n\nzero.toNumber = function() { return 0; };\nzero.zzEncode = zero.zzDecode = function() { return this; };\nzero.length = function() { return 1; };\n\n/**\n * Zero hash.\n * @memberof util.LongBits\n * @type {string}\n */\nvar zeroHash = LongBits.zeroHash = \"\\0\\0\\0\\0\\0\\0\\0\\0\";\n\n/**\n * Constructs new long bits from the specified number.\n * @param {number} value Value\n * @returns {util.LongBits} Instance\n */\nLongBits.fromNumber = function fromNumber(value) {\n    if (value === 0)\n        return zero;\n    var sign = value < 0;\n    if (sign)\n        value = -value;\n    var lo = value >>> 0,\n        hi = (value - lo) / 4294967296 >>> 0;\n    if (sign) {\n        hi = ~hi >>> 0;\n        lo = ~lo >>> 0;\n        if (++lo > 4294967295) {\n            lo = 0;\n            if (++hi > 4294967295)\n                hi = 0;\n        }\n    }\n    return new LongBits(lo, hi);\n};\n\n/**\n * Constructs new long bits from a number, long or string.\n * @param {Long|number|string} value Value\n * @returns {util.LongBits} Instance\n */\nLongBits.from = function from(value) {\n    if (typeof value === \"number\")\n        return LongBits.fromNumber(value);\n    if (util.isString(value)) {\n        /* istanbul ignore else */\n        if (util.Long)\n            value = util.Long.fromString(value);\n        else\n            return LongBits.fromNumber(parseInt(value, 10));\n    }\n    return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;\n};\n\n/**\n * Converts this long bits to a possibly unsafe JavaScript number.\n * @param {boolean} [unsigned=false] Whether unsigned or not\n * @returns {number} Possibly unsafe number\n */\nLongBits.prototype.toNumber = function toNumber(unsigned) {\n    if (!unsigned && this.hi >>> 31) {\n        var lo = ~this.lo + 1 >>> 0,\n            hi = ~this.hi     >>> 0;\n        if (!lo)\n            hi = hi + 1 >>> 0;\n        return -(lo + hi * 4294967296);\n    }\n    return this.lo + this.hi * 4294967296;\n};\n\n/**\n * Converts this long bits to a long.\n * @param {boolean} [unsigned=false] Whether unsigned or not\n * @returns {Long} Long\n */\nLongBits.prototype.toLong = function toLong(unsigned) {\n    return util.Long\n        ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned))\n        /* istanbul ignore next */\n        : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };\n};\n\nvar charCodeAt = String.prototype.charCodeAt;\n\n/**\n * Constructs new long bits from the specified 8 characters long hash.\n * @param {string} hash Hash\n * @returns {util.LongBits} Bits\n */\nLongBits.fromHash = function fromHash(hash) {\n    if (hash === zeroHash)\n        return zero;\n    return new LongBits(\n        ( charCodeAt.call(hash, 0)\n        | charCodeAt.call(hash, 1) << 8\n        | charCodeAt.call(hash, 2) << 16\n        | charCodeAt.call(hash, 3) << 24) >>> 0\n    ,\n        ( charCodeAt.call(hash, 4)\n        | charCodeAt.call(hash, 5) << 8\n        | charCodeAt.call(hash, 6) << 16\n        | charCodeAt.call(hash, 7) << 24) >>> 0\n    );\n};\n\n/**\n * Converts this long bits to a 8 characters long hash.\n * @returns {string} Hash\n */\nLongBits.prototype.toHash = function toHash() {\n    return String.fromCharCode(\n        this.lo        & 255,\n        this.lo >>> 8  & 255,\n        this.lo >>> 16 & 255,\n        this.lo >>> 24      ,\n        this.hi        & 255,\n        this.hi >>> 8  & 255,\n        this.hi >>> 16 & 255,\n        this.hi >>> 24\n    );\n};\n\n/**\n * Zig-zag encodes this long bits.\n * @returns {util.LongBits} `this`\n */\nLongBits.prototype.zzEncode = function zzEncode() {\n    var mask =   this.hi >> 31;\n    this.hi  = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;\n    this.lo  = ( this.lo << 1                   ^ mask) >>> 0;\n    return this;\n};\n\n/**\n * Zig-zag decodes this long bits.\n * @returns {util.LongBits} `this`\n */\nLongBits.prototype.zzDecode = function zzDecode() {\n    var mask = -(this.lo & 1);\n    this.lo  = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;\n    this.hi  = ( this.hi >>> 1                  ^ mask) >>> 0;\n    return this;\n};\n\n/**\n * Calculates the length of this longbits when encoded as a varint.\n * @returns {number} Length\n */\nLongBits.prototype.length = function length() {\n    var part0 =  this.lo,\n        part1 = (this.lo >>> 28 | this.hi << 4) >>> 0,\n        part2 =  this.hi >>> 24;\n    return part2 === 0\n         ? part1 === 0\n           ? part0 < 16384\n             ? part0 < 128 ? 1 : 2\n             : part0 < 2097152 ? 3 : 4\n           : part1 < 16384\n             ? part1 < 128 ? 5 : 6\n             : part1 < 2097152 ? 7 : 8\n         : part2 < 128 ? 9 : 10;\n};\n","\"use strict\";\nvar util = exports;\n\n// used to return a Promise where callback is omitted\nutil.asPromise = require(\"@protobufjs/aspromise\");\n\n// converts to / from base64 encoded strings\nutil.base64 = require(\"@protobufjs/base64\");\n\n// base class of rpc.Service\nutil.EventEmitter = require(\"@protobufjs/eventemitter\");\n\n// float handling accross browsers\nutil.float = require(\"@protobufjs/float\");\n\n// requires modules optionally and hides the call from bundlers\nutil.inquire = require(\"@protobufjs/inquire\");\n\n// converts to / from utf8 encoded strings\nutil.utf8 = require(\"@protobufjs/utf8\");\n\n// provides a node-like buffer pool in the browser\nutil.pool = require(\"@protobufjs/pool\");\n\n// utility to work with the low and high bits of a 64 bit value\nutil.LongBits = require(\"./longbits\");\n\n/**\n * Whether running within node or not.\n * @memberof util\n * @type {boolean}\n */\nutil.isNode = Boolean(typeof global !== \"undefined\"\n                   && global\n                   && global.process\n                   && global.process.versions\n                   && global.process.versions.node);\n\n/**\n * Global object reference.\n * @memberof util\n * @type {Object}\n */\nutil.global = util.isNode && global\n           || typeof window !== \"undefined\" && window\n           || typeof self   !== \"undefined\" && self\n           || this; // eslint-disable-line no-invalid-this\n\n/**\n * An immuable empty array.\n * @memberof util\n * @type {Array.<*>}\n * @const\n */\nutil.emptyArray = Object.freeze ? Object.freeze([]) : /* istanbul ignore next */ []; // used on prototypes\n\n/**\n * An immutable empty object.\n * @type {Object}\n * @const\n */\nutil.emptyObject = Object.freeze ? Object.freeze({}) : /* istanbul ignore next */ {}; // used on prototypes\n\n/**\n * Tests if the specified value is an integer.\n * @function\n * @param {*} value Value to test\n * @returns {boolean} `true` if the value is an integer\n */\nutil.isInteger = Number.isInteger || /* istanbul ignore next */ function isInteger(value) {\n    return typeof value === \"number\" && isFinite(value) && Math.floor(value) === value;\n};\n\n/**\n * Tests if the specified value is a string.\n * @param {*} value Value to test\n * @returns {boolean} `true` if the value is a string\n */\nutil.isString = function isString(value) {\n    return typeof value === \"string\" || value instanceof String;\n};\n\n/**\n * Tests if the specified value is a non-null object.\n * @param {*} value Value to test\n * @returns {boolean} `true` if the value is a non-null object\n */\nutil.isObject = function isObject(value) {\n    return value && typeof value === \"object\";\n};\n\n/**\n * Checks if a property on a message is considered to be present.\n * This is an alias of {@link util.isSet}.\n * @function\n * @param {Object} obj Plain object or message instance\n * @param {string} prop Property name\n * @returns {boolean} `true` if considered to be present, otherwise `false`\n */\nutil.isset =\n\n/**\n * Checks if a property on a message is considered to be present.\n * @param {Object} obj Plain object or message instance\n * @param {string} prop Property name\n * @returns {boolean} `true` if considered to be present, otherwise `false`\n */\nutil.isSet = function isSet(obj, prop) {\n    var value = obj[prop];\n    if (value != null && obj.hasOwnProperty(prop)) // eslint-disable-line eqeqeq, no-prototype-builtins\n        return typeof value !== \"object\" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;\n    return false;\n};\n\n/**\n * Any compatible Buffer instance.\n * This is a minimal stand-alone definition of a Buffer instance. The actual type is that exported by node's typings.\n * @interface Buffer\n * @extends Uint8Array\n */\n\n/**\n * Node's Buffer class if available.\n * @type {Constructor<Buffer>}\n */\nutil.Buffer = (function() {\n    try {\n        var Buffer = util.inquire(\"buffer\").Buffer;\n        // refuse to use non-node buffers if not explicitly assigned (perf reasons):\n        return Buffer.prototype.utf8Write ? Buffer : /* istanbul ignore next */ null;\n    } catch (e) {\n        /* istanbul ignore next */\n        return null;\n    }\n})();\n\n// Internal alias of or polyfull for Buffer.from.\nutil._Buffer_from = null;\n\n// Internal alias of or polyfill for Buffer.allocUnsafe.\nutil._Buffer_allocUnsafe = null;\n\n/**\n * Creates a new buffer of whatever type supported by the environment.\n * @param {number|number[]} [sizeOrArray=0] Buffer size or number array\n * @returns {Uint8Array|Buffer} Buffer\n */\nutil.newBuffer = function newBuffer(sizeOrArray) {\n    /* istanbul ignore next */\n    return typeof sizeOrArray === \"number\"\n        ? util.Buffer\n            ? util._Buffer_allocUnsafe(sizeOrArray)\n            : new util.Array(sizeOrArray)\n        : util.Buffer\n            ? util._Buffer_from(sizeOrArray)\n            : typeof Uint8Array === \"undefined\"\n                ? sizeOrArray\n                : new Uint8Array(sizeOrArray);\n};\n\n/**\n * Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.\n * @type {Constructor<Uint8Array>}\n */\nutil.Array = typeof Uint8Array !== \"undefined\" ? Uint8Array /* istanbul ignore next */ : Array;\n\n/**\n * Any compatible Long instance.\n * This is a minimal stand-alone definition of a Long instance. The actual type is that exported by long.js.\n * @interface Long\n * @property {number} low Low bits\n * @property {number} high High bits\n * @property {boolean} unsigned Whether unsigned or not\n */\n\n/**\n * Long.js's Long class if available.\n * @type {Constructor<Long>}\n */\nutil.Long = /* istanbul ignore next */ util.global.dcodeIO && /* istanbul ignore next */ util.global.dcodeIO.Long\n         || /* istanbul ignore next */ util.global.Long\n         || util.inquire(\"long\");\n\n/**\n * Regular expression used to verify 2 bit (`bool`) map keys.\n * @type {RegExp}\n * @const\n */\nutil.key2Re = /^true|false|0|1$/;\n\n/**\n * Regular expression used to verify 32 bit (`int32` etc.) map keys.\n * @type {RegExp}\n * @const\n */\nutil.key32Re = /^-?(?:0|[1-9][0-9]*)$/;\n\n/**\n * Regular expression used to verify 64 bit (`int64` etc.) map keys.\n * @type {RegExp}\n * @const\n */\nutil.key64Re = /^(?:[\\\\x00-\\\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;\n\n/**\n * Converts a number or long to an 8 characters long hash string.\n * @param {Long|number} value Value to convert\n * @returns {string} Hash\n */\nutil.longToHash = function longToHash(value) {\n    return value\n        ? util.LongBits.from(value).toHash()\n        : util.LongBits.zeroHash;\n};\n\n/**\n * Converts an 8 characters long hash string to a long or number.\n * @param {string} hash Hash\n * @param {boolean} [unsigned=false] Whether unsigned or not\n * @returns {Long|number} Original value\n */\nutil.longFromHash = function longFromHash(hash, unsigned) {\n    var bits = util.LongBits.fromHash(hash);\n    if (util.Long)\n        return util.Long.fromBits(bits.lo, bits.hi, unsigned);\n    return bits.toNumber(Boolean(unsigned));\n};\n\n/**\n * Merges the properties of the source object into the destination object.\n * @memberof util\n * @param {Object.<string,*>} dst Destination object\n * @param {Object.<string,*>} src Source object\n * @param {boolean} [ifNotSet=false] Merges only if the key is not already set\n * @returns {Object.<string,*>} Destination object\n */\nfunction merge(dst, src, ifNotSet) { // used by converters\n    for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)\n        if (dst[keys[i]] === undefined || !ifNotSet)\n            dst[keys[i]] = src[keys[i]];\n    return dst;\n}\n\nutil.merge = merge;\n\n/**\n * Converts the first character of a string to lower case.\n * @param {string} str String to convert\n * @returns {string} Converted string\n */\nutil.lcFirst = function lcFirst(str) {\n    return str.charAt(0).toLowerCase() + str.substring(1);\n};\n\n/**\n * Creates a custom error constructor.\n * @memberof util\n * @param {string} name Error name\n * @returns {Constructor<Error>} Custom error constructor\n */\nfunction newError(name) {\n\n    function CustomError(message, properties) {\n\n        if (!(this instanceof CustomError))\n            return new CustomError(message, properties);\n\n        // Error.call(this, message);\n        // ^ just returns a new error instance because the ctor can be called as a function\n\n        Object.defineProperty(this, \"message\", { get: function() { return message; } });\n\n        /* istanbul ignore next */\n        if (Error.captureStackTrace) // node\n            Error.captureStackTrace(this, CustomError);\n        else\n            Object.defineProperty(this, \"stack\", { value: new Error().stack || \"\" });\n\n        if (properties)\n            merge(this, properties);\n    }\n\n    (CustomError.prototype = Object.create(Error.prototype)).constructor = CustomError;\n\n    Object.defineProperty(CustomError.prototype, \"name\", { get: function() { return name; } });\n\n    CustomError.prototype.toString = function toString() {\n        return this.name + \": \" + this.message;\n    };\n\n    return CustomError;\n}\n\nutil.newError = newError;\n\n/**\n * Constructs a new protocol error.\n * @classdesc Error subclass indicating a protocol specifc error.\n * @memberof util\n * @extends Error\n * @template T extends Message<T>\n * @constructor\n * @param {string} message Error message\n * @param {Object.<string,*>} [properties] Additional properties\n * @example\n * try {\n *     MyMessage.decode(someBuffer); // throws if required fields are missing\n * } catch (e) {\n *     if (e instanceof ProtocolError && e.instance)\n *         console.log(\"decoded so far: \" + JSON.stringify(e.instance));\n * }\n */\nutil.ProtocolError = newError(\"ProtocolError\");\n\n/**\n * So far decoded message instance.\n * @name util.ProtocolError#instance\n * @type {Message<T>}\n */\n\n/**\n * A OneOf getter as returned by {@link util.oneOfGetter}.\n * @typedef OneOfGetter\n * @type {function}\n * @returns {string|undefined} Set field name, if any\n */\n\n/**\n * Builds a getter for a oneof's present field name.\n * @param {string[]} fieldNames Field names\n * @returns {OneOfGetter} Unbound getter\n */\nutil.oneOfGetter = function getOneOf(fieldNames) {\n    var fieldMap = {};\n    for (var i = 0; i < fieldNames.length; ++i)\n        fieldMap[fieldNames[i]] = 1;\n\n    /**\n     * @returns {string|undefined} Set field name, if any\n     * @this Object\n     * @ignore\n     */\n    return function() { // eslint-disable-line consistent-return\n        for (var keys = Object.keys(this), i = keys.length - 1; i > -1; --i)\n            if (fieldMap[keys[i]] === 1 && this[keys[i]] !== undefined && this[keys[i]] !== null)\n                return keys[i];\n    };\n};\n\n/**\n * A OneOf setter as returned by {@link util.oneOfSetter}.\n * @typedef OneOfSetter\n * @type {function}\n * @param {string|undefined} value Field name\n * @returns {undefined}\n */\n\n/**\n * Builds a setter for a oneof's present field name.\n * @param {string[]} fieldNames Field names\n * @returns {OneOfSetter} Unbound setter\n */\nutil.oneOfSetter = function setOneOf(fieldNames) {\n\n    /**\n     * @param {string} name Field name\n     * @returns {undefined}\n     * @this Object\n     * @ignore\n     */\n    return function(name) {\n        for (var i = 0; i < fieldNames.length; ++i)\n            if (fieldNames[i] !== name)\n                delete this[fieldNames[i]];\n    };\n};\n\n/**\n * Default conversion options used for {@link Message#toJSON} implementations.\n *\n * These options are close to proto3's JSON mapping with the exception that internal types like Any are handled just like messages. More precisely:\n *\n * - Longs become strings\n * - Enums become string keys\n * - Bytes become base64 encoded strings\n * - (Sub-)Messages become plain objects\n * - Maps become plain objects with all string keys\n * - Repeated fields become arrays\n * - NaN and Infinity for float and double fields become strings\n *\n * @type {IConversionOptions}\n * @see https://developers.google.com/protocol-buffers/docs/proto3?hl=en#json\n */\nutil.toJSONOptions = {\n    longs: String,\n    enums: String,\n    bytes: String,\n    json: true\n};\n\n// Sets up buffer utility according to the environment (called in index-minimal)\nutil._configure = function() {\n    var Buffer = util.Buffer;\n    /* istanbul ignore if */\n    if (!Buffer) {\n        util._Buffer_from = util._Buffer_allocUnsafe = null;\n        return;\n    }\n    // because node 4.x buffers are incompatible & immutable\n    // see: https://github.com/dcodeIO/protobuf.js/pull/665\n    util._Buffer_from = Buffer.from !== Uint8Array.from && Buffer.from ||\n        /* istanbul ignore next */\n        function Buffer_from(value, encoding) {\n            return new Buffer(value, encoding);\n        };\n    util._Buffer_allocUnsafe = Buffer.allocUnsafe ||\n        /* istanbul ignore next */\n        function Buffer_allocUnsafe(size) {\n            return new Buffer(size);\n        };\n};\n","\"use strict\";\nmodule.exports = Writer;\n\nvar util      = require(\"./util/minimal\");\n\nvar BufferWriter; // cyclic\n\nvar LongBits  = util.LongBits,\n    base64    = util.base64,\n    utf8      = util.utf8;\n\n/**\n * Constructs a new writer operation instance.\n * @classdesc Scheduled writer operation.\n * @constructor\n * @param {function(*, Uint8Array, number)} fn Function to call\n * @param {number} len Value byte length\n * @param {*} val Value to write\n * @ignore\n */\nfunction Op(fn, len, val) {\n\n    /**\n     * Function to call.\n     * @type {function(Uint8Array, number, *)}\n     */\n    this.fn = fn;\n\n    /**\n     * Value byte length.\n     * @type {number}\n     */\n    this.len = len;\n\n    /**\n     * Next operation.\n     * @type {Writer.Op|undefined}\n     */\n    this.next = undefined;\n\n    /**\n     * Value to write.\n     * @type {*}\n     */\n    this.val = val; // type varies\n}\n\n/* istanbul ignore next */\nfunction noop() {} // eslint-disable-line no-empty-function\n\n/**\n * Constructs a new writer state instance.\n * @classdesc Copied writer state.\n * @memberof Writer\n * @constructor\n * @param {Writer} writer Writer to copy state from\n * @ignore\n */\nfunction State(writer) {\n\n    /**\n     * Current head.\n     * @type {Writer.Op}\n     */\n    this.head = writer.head;\n\n    /**\n     * Current tail.\n     * @type {Writer.Op}\n     */\n    this.tail = writer.tail;\n\n    /**\n     * Current buffer length.\n     * @type {number}\n     */\n    this.len = writer.len;\n\n    /**\n     * Next state.\n     * @type {State|null}\n     */\n    this.next = writer.states;\n}\n\n/**\n * Constructs a new writer instance.\n * @classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.\n * @constructor\n */\nfunction Writer() {\n\n    /**\n     * Current length.\n     * @type {number}\n     */\n    this.len = 0;\n\n    /**\n     * Operations head.\n     * @type {Object}\n     */\n    this.head = new Op(noop, 0, 0);\n\n    /**\n     * Operations tail\n     * @type {Object}\n     */\n    this.tail = this.head;\n\n    /**\n     * Linked forked states.\n     * @type {Object|null}\n     */\n    this.states = null;\n\n    // When a value is written, the writer calculates its byte length and puts it into a linked\n    // list of operations to perform when finish() is called. This both allows us to allocate\n    // buffers of the exact required size and reduces the amount of work we have to do compared\n    // to first calculating over objects and then encoding over objects. In our case, the encoding\n    // part is just a linked list walk calling operations with already prepared values.\n}\n\nvar create = function create() {\n    return util.Buffer\n        ? function create_buffer_setup() {\n            return (Writer.create = function create_buffer() {\n                return new BufferWriter();\n            })();\n        }\n        /* istanbul ignore next */\n        : function create_array() {\n            return new Writer();\n        };\n};\n\n/**\n * Creates a new writer.\n * @function\n * @returns {BufferWriter|Writer} A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}\n */\nWriter.create = create();\n\n/**\n * Allocates a buffer of the specified size.\n * @param {number} size Buffer size\n * @returns {Uint8Array} Buffer\n */\nWriter.alloc = function alloc(size) {\n    return new util.Array(size);\n};\n\n// Use Uint8Array buffer pool in the browser, just like node does with buffers\n/* istanbul ignore else */\nif (util.Array !== Array)\n    Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);\n\n/**\n * Pushes a new operation to the queue.\n * @param {function(Uint8Array, number, *)} fn Function to call\n * @param {number} len Value byte length\n * @param {number} val Value to write\n * @returns {Writer} `this`\n * @private\n */\nWriter.prototype._push = function push(fn, len, val) {\n    this.tail = this.tail.next = new Op(fn, len, val);\n    this.len += len;\n    return this;\n};\n\nfunction writeByte(val, buf, pos) {\n    buf[pos] = val & 255;\n}\n\nfunction writeVarint32(val, buf, pos) {\n    while (val > 127) {\n        buf[pos++] = val & 127 | 128;\n        val >>>= 7;\n    }\n    buf[pos] = val;\n}\n\n/**\n * Constructs a new varint writer operation instance.\n * @classdesc Scheduled varint writer operation.\n * @extends Op\n * @constructor\n * @param {number} len Value byte length\n * @param {number} val Value to write\n * @ignore\n */\nfunction VarintOp(len, val) {\n    this.len = len;\n    this.next = undefined;\n    this.val = val;\n}\n\nVarintOp.prototype = Object.create(Op.prototype);\nVarintOp.prototype.fn = writeVarint32;\n\n/**\n * Writes an unsigned 32 bit value as a varint.\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.uint32 = function write_uint32(value) {\n    // here, the call to this.push has been inlined and a varint specific Op subclass is used.\n    // uint32 is by far the most frequently used operation and benefits significantly from this.\n    this.len += (this.tail = this.tail.next = new VarintOp(\n        (value = value >>> 0)\n                < 128       ? 1\n        : value < 16384     ? 2\n        : value < 2097152   ? 3\n        : value < 268435456 ? 4\n        :                     5,\n    value)).len;\n    return this;\n};\n\n/**\n * Writes a signed 32 bit value as a varint.\n * @function\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.int32 = function write_int32(value) {\n    return value < 0\n        ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) // 10 bytes per spec\n        : this.uint32(value);\n};\n\n/**\n * Writes a 32 bit value as a varint, zig-zag encoded.\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.sint32 = function write_sint32(value) {\n    return this.uint32((value << 1 ^ value >> 31) >>> 0);\n};\n\nfunction writeVarint64(val, buf, pos) {\n    while (val.hi) {\n        buf[pos++] = val.lo & 127 | 128;\n        val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;\n        val.hi >>>= 7;\n    }\n    while (val.lo > 127) {\n        buf[pos++] = val.lo & 127 | 128;\n        val.lo = val.lo >>> 7;\n    }\n    buf[pos++] = val.lo;\n}\n\n/**\n * Writes an unsigned 64 bit value as a varint.\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.uint64 = function write_uint64(value) {\n    var bits = LongBits.from(value);\n    return this._push(writeVarint64, bits.length(), bits);\n};\n\n/**\n * Writes a signed 64 bit value as a varint.\n * @function\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.int64 = Writer.prototype.uint64;\n\n/**\n * Writes a signed 64 bit value as a varint, zig-zag encoded.\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.sint64 = function write_sint64(value) {\n    var bits = LongBits.from(value).zzEncode();\n    return this._push(writeVarint64, bits.length(), bits);\n};\n\n/**\n * Writes a boolish value as a varint.\n * @param {boolean} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.bool = function write_bool(value) {\n    return this._push(writeByte, 1, value ? 1 : 0);\n};\n\nfunction writeFixed32(val, buf, pos) {\n    buf[pos    ] =  val         & 255;\n    buf[pos + 1] =  val >>> 8   & 255;\n    buf[pos + 2] =  val >>> 16  & 255;\n    buf[pos + 3] =  val >>> 24;\n}\n\n/**\n * Writes an unsigned 32 bit value as fixed 32 bits.\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.fixed32 = function write_fixed32(value) {\n    return this._push(writeFixed32, 4, value >>> 0);\n};\n\n/**\n * Writes a signed 32 bit value as fixed 32 bits.\n * @function\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.sfixed32 = Writer.prototype.fixed32;\n\n/**\n * Writes an unsigned 64 bit value as fixed 64 bits.\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.fixed64 = function write_fixed64(value) {\n    var bits = LongBits.from(value);\n    return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);\n};\n\n/**\n * Writes a signed 64 bit value as fixed 64 bits.\n * @function\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.sfixed64 = Writer.prototype.fixed64;\n\n/**\n * Writes a float (32 bit).\n * @function\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.float = function write_float(value) {\n    return this._push(util.float.writeFloatLE, 4, value);\n};\n\n/**\n * Writes a double (64 bit float).\n * @function\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.double = function write_double(value) {\n    return this._push(util.float.writeDoubleLE, 8, value);\n};\n\nvar writeBytes = util.Array.prototype.set\n    ? function writeBytes_set(val, buf, pos) {\n        buf.set(val, pos); // also works for plain array values\n    }\n    /* istanbul ignore next */\n    : function writeBytes_for(val, buf, pos) {\n        for (var i = 0; i < val.length; ++i)\n            buf[pos + i] = val[i];\n    };\n\n/**\n * Writes a sequence of bytes.\n * @param {Uint8Array|string} value Buffer or base64 encoded string to write\n * @returns {Writer} `this`\n */\nWriter.prototype.bytes = function write_bytes(value) {\n    var len = value.length >>> 0;\n    if (!len)\n        return this._push(writeByte, 1, 0);\n    if (util.isString(value)) {\n        var buf = Writer.alloc(len = base64.length(value));\n        base64.decode(value, buf, 0);\n        value = buf;\n    }\n    return this.uint32(len)._push(writeBytes, len, value);\n};\n\n/**\n * Writes a string.\n * @param {string} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.string = function write_string(value) {\n    var len = utf8.length(value);\n    return len\n        ? this.uint32(len)._push(utf8.write, len, value)\n        : this._push(writeByte, 1, 0);\n};\n\n/**\n * Forks this writer's state by pushing it to a stack.\n * Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.\n * @returns {Writer} `this`\n */\nWriter.prototype.fork = function fork() {\n    this.states = new State(this);\n    this.head = this.tail = new Op(noop, 0, 0);\n    this.len = 0;\n    return this;\n};\n\n/**\n * Resets this instance to the last state.\n * @returns {Writer} `this`\n */\nWriter.prototype.reset = function reset() {\n    if (this.states) {\n        this.head   = this.states.head;\n        this.tail   = this.states.tail;\n        this.len    = this.states.len;\n        this.states = this.states.next;\n    } else {\n        this.head = this.tail = new Op(noop, 0, 0);\n        this.len  = 0;\n    }\n    return this;\n};\n\n/**\n * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.\n * @returns {Writer} `this`\n */\nWriter.prototype.ldelim = function ldelim() {\n    var head = this.head,\n        tail = this.tail,\n        len  = this.len;\n    this.reset().uint32(len);\n    if (len) {\n        this.tail.next = head.next; // skip noop\n        this.tail = tail;\n        this.len += len;\n    }\n    return this;\n};\n\n/**\n * Finishes the write operation.\n * @returns {Uint8Array} Finished buffer\n */\nWriter.prototype.finish = function finish() {\n    var head = this.head.next, // skip noop\n        buf  = this.constructor.alloc(this.len),\n        pos  = 0;\n    while (head) {\n        head.fn(head.val, buf, pos);\n        pos += head.len;\n        head = head.next;\n    }\n    // this.head = this.tail = null;\n    return buf;\n};\n\nWriter._configure = function(BufferWriter_) {\n    BufferWriter = BufferWriter_;\n    Writer.create = create();\n    BufferWriter._configure();\n};\n","\"use strict\";\nmodule.exports = BufferWriter;\n\n// extends Writer\nvar Writer = require(\"./writer\");\n(BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;\n\nvar util = require(\"./util/minimal\");\n\n/**\n * Constructs a new buffer writer instance.\n * @classdesc Wire format writer using node buffers.\n * @extends Writer\n * @constructor\n */\nfunction BufferWriter() {\n    Writer.call(this);\n}\n\nBufferWriter._configure = function () {\n    /**\n     * Allocates a buffer of the specified size.\n     * @function\n     * @param {number} size Buffer size\n     * @returns {Buffer} Buffer\n     */\n    BufferWriter.alloc = util._Buffer_allocUnsafe;\n\n    BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === \"set\"\n        ? function writeBytesBuffer_set(val, buf, pos) {\n          buf.set(val, pos); // faster than copy (requires node >= 4 where Buffers extend Uint8Array and set is properly inherited)\n          // also works for plain array values\n        }\n        /* istanbul ignore next */\n        : function writeBytesBuffer_copy(val, buf, pos) {\n          if (val.copy) // Buffer values\n            val.copy(buf, pos, 0, val.length);\n          else for (var i = 0; i < val.length;) // plain array values\n            buf[pos++] = val[i++];\n        };\n};\n\n\n/**\n * @override\n */\nBufferWriter.prototype.bytes = function write_bytes_buffer(value) {\n    if (util.isString(value))\n        value = util._Buffer_from(value, \"base64\");\n    var len = value.length >>> 0;\n    this.uint32(len);\n    if (len)\n        this._push(BufferWriter.writeBytesBuffer, len, value);\n    return this;\n};\n\nfunction writeStringBuffer(val, buf, pos) {\n    if (val.length < 40) // plain js is faster for short strings (probably due to redundant assertions)\n        util.utf8.write(val, buf, pos);\n    else if (buf.utf8Write)\n        buf.utf8Write(val, pos);\n    else\n        buf.write(val, pos);\n}\n\n/**\n * @override\n */\nBufferWriter.prototype.string = function write_string_buffer(value) {\n    var len = util.Buffer.byteLength(value);\n    this.uint32(len);\n    if (len)\n        this._push(writeStringBuffer, len, value);\n    return this;\n};\n\n\n/**\n * Finishes the write operation.\n * @name BufferWriter#finish\n * @function\n * @returns {Buffer} Finished buffer\n */\n\nBufferWriter._configure();\n","/*! https://mths.be/punycode v1.4.1 by @mathias */\n;(function(root) {\n\n\t/** Detect free variables */\n\tvar freeExports = typeof exports == 'object' && exports &&\n\t\t!exports.nodeType && exports;\n\tvar freeModule = typeof module == 'object' && module &&\n\t\t!module.nodeType && module;\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (\n\t\tfreeGlobal.global === freeGlobal ||\n\t\tfreeGlobal.window === freeGlobal ||\n\t\tfreeGlobal.self === freeGlobal\n\t) {\n\t\troot = freeGlobal;\n\t}\n\n\t/**\n\t * The `punycode` object.\n\t * @name punycode\n\t * @type Object\n\t */\n\tvar punycode,\n\n\t/** Highest positive signed 32-bit float value */\n\tmaxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1\n\n\t/** Bootstring parameters */\n\tbase = 36,\n\ttMin = 1,\n\ttMax = 26,\n\tskew = 38,\n\tdamp = 700,\n\tinitialBias = 72,\n\tinitialN = 128, // 0x80\n\tdelimiter = '-', // '\\x2D'\n\n\t/** Regular expressions */\n\tregexPunycode = /^xn--/,\n\tregexNonASCII = /[^\\x20-\\x7E]/, // unprintable ASCII chars + non-ASCII chars\n\tregexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g, // RFC 3490 separators\n\n\t/** Error messages */\n\terrors = {\n\t\t'overflow': 'Overflow: input needs wider integers to process',\n\t\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t\t'invalid-input': 'Invalid input'\n\t},\n\n\t/** Convenience shortcuts */\n\tbaseMinusTMin = base - tMin,\n\tfloor = Math.floor,\n\tstringFromCharCode = String.fromCharCode,\n\n\t/** Temporary variable */\n\tkey;\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/**\n\t * A generic error utility function.\n\t * @private\n\t * @param {String} type The error type.\n\t * @returns {Error} Throws a `RangeError` with the applicable error message.\n\t */\n\tfunction error(type) {\n\t\tthrow new RangeError(errors[type]);\n\t}\n\n\t/**\n\t * A generic `Array#map` utility function.\n\t * @private\n\t * @param {Array} array The array to iterate over.\n\t * @param {Function} callback The function that gets called for every array\n\t * item.\n\t * @returns {Array} A new array of values returned by the callback function.\n\t */\n\tfunction map(array, fn) {\n\t\tvar length = array.length;\n\t\tvar result = [];\n\t\twhile (length--) {\n\t\t\tresult[length] = fn(array[length]);\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * A simple `Array#map`-like wrapper to work with domain name strings or email\n\t * addresses.\n\t * @private\n\t * @param {String} domain The domain name or email address.\n\t * @param {Function} callback The function that gets called for every\n\t * character.\n\t * @returns {Array} A new string of characters returned by the callback\n\t * function.\n\t */\n\tfunction mapDomain(string, fn) {\n\t\tvar parts = string.split('@');\n\t\tvar result = '';\n\t\tif (parts.length > 1) {\n\t\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t\t// the local part (i.e. everything up to `@`) intact.\n\t\t\tresult = parts[0] + '@';\n\t\t\tstring = parts[1];\n\t\t}\n\t\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\t\tstring = string.replace(regexSeparators, '\\x2E');\n\t\tvar labels = string.split('.');\n\t\tvar encoded = map(labels, fn).join('.');\n\t\treturn result + encoded;\n\t}\n\n\t/**\n\t * Creates an array containing the numeric code points of each Unicode\n\t * character in the string. While JavaScript uses UCS-2 internally,\n\t * this function will convert a pair of surrogate halves (each of which\n\t * UCS-2 exposes as separate characters) into a single code point,\n\t * matching UTF-16.\n\t * @see `punycode.ucs2.encode`\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode.ucs2\n\t * @name decode\n\t * @param {String} string The Unicode input string (UCS-2).\n\t * @returns {Array} The new array of code points.\n\t */\n\tfunction ucs2decode(string) {\n\t\tvar output = [],\n\t\t    counter = 0,\n\t\t    length = string.length,\n\t\t    value,\n\t\t    extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t/**\n\t * Creates a string based on an array of numeric code points.\n\t * @see `punycode.ucs2.decode`\n\t * @memberOf punycode.ucs2\n\t * @name encode\n\t * @param {Array} codePoints The array of numeric code points.\n\t * @returns {String} The new Unicode string (UCS-2).\n\t */\n\tfunction ucs2encode(array) {\n\t\treturn map(array, function(value) {\n\t\t\tvar output = '';\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t\treturn output;\n\t\t}).join('');\n\t}\n\n\t/**\n\t * Converts a basic code point into a digit/integer.\n\t * @see `digitToBasic()`\n\t * @private\n\t * @param {Number} codePoint The basic numeric code point value.\n\t * @returns {Number} The numeric value of a basic code point (for use in\n\t * representing integers) in the range `0` to `base - 1`, or `base` if\n\t * the code point does not represent a value.\n\t */\n\tfunction basicToDigit(codePoint) {\n\t\tif (codePoint - 48 < 10) {\n\t\t\treturn codePoint - 22;\n\t\t}\n\t\tif (codePoint - 65 < 26) {\n\t\t\treturn codePoint - 65;\n\t\t}\n\t\tif (codePoint - 97 < 26) {\n\t\t\treturn codePoint - 97;\n\t\t}\n\t\treturn base;\n\t}\n\n\t/**\n\t * Converts a digit/integer into a basic code point.\n\t * @see `basicToDigit()`\n\t * @private\n\t * @param {Number} digit The numeric value of a basic code point.\n\t * @returns {Number} The basic code point whose value (when used for\n\t * representing integers) is `digit`, which needs to be in the range\n\t * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n\t * used; else, the lowercase form is used. The behavior is undefined\n\t * if `flag` is non-zero and `digit` has no uppercase form.\n\t */\n\tfunction digitToBasic(digit, flag) {\n\t\t//  0..25 map to ASCII a..z or A..Z\n\t\t// 26..35 map to ASCII 0..9\n\t\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n\t}\n\n\t/**\n\t * Bias adaptation function as per section 3.4 of RFC 3492.\n\t * https://tools.ietf.org/html/rfc3492#section-3.4\n\t * @private\n\t */\n\tfunction adapt(delta, numPoints, firstTime) {\n\t\tvar k = 0;\n\t\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\t\tdelta += floor(delta / numPoints);\n\t\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\t\tdelta = floor(delta / baseMinusTMin);\n\t\t}\n\t\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n\t}\n\n\t/**\n\t * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n\t * symbols.\n\t * @memberOf punycode\n\t * @param {String} input The Punycode string of ASCII-only symbols.\n\t * @returns {String} The resulting string of Unicode symbols.\n\t */\n\tfunction decode(input) {\n\t\t// Don't use UCS-2\n\t\tvar output = [],\n\t\t    inputLength = input.length,\n\t\t    out,\n\t\t    i = 0,\n\t\t    n = initialN,\n\t\t    bias = initialBias,\n\t\t    basic,\n\t\t    j,\n\t\t    index,\n\t\t    oldi,\n\t\t    w,\n\t\t    k,\n\t\t    digit,\n\t\t    t,\n\t\t    /** Cached calculation results */\n\t\t    baseMinusT;\n\n\t\t// Handle the basic code points: let `basic` be the number of input code\n\t\t// points before the last delimiter, or `0` if there is none, then copy\n\t\t// the first basic code points to the output.\n\n\t\tbasic = input.lastIndexOf(delimiter);\n\t\tif (basic < 0) {\n\t\t\tbasic = 0;\n\t\t}\n\n\t\tfor (j = 0; j < basic; ++j) {\n\t\t\t// if it's not a basic code point\n\t\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\t\terror('not-basic');\n\t\t\t}\n\t\t\toutput.push(input.charCodeAt(j));\n\t\t}\n\n\t\t// Main decoding loop: start just after the last delimiter if any basic code\n\t\t// points were copied; start at the beginning otherwise.\n\n\t\tfor (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t\t// `index` is the index of the next character to be consumed.\n\t\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t\t// which gets added to `i`. The overflow checking is easier\n\t\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t\t// value at the end to obtain `delta`.\n\t\t\tfor (oldi = i, w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\t\tif (index >= inputLength) {\n\t\t\t\t\terror('invalid-input');\n\t\t\t\t}\n\n\t\t\t\tdigit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\ti += digit * w;\n\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\t\tif (digit < t) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tbaseMinusT = base - t;\n\t\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tw *= baseMinusT;\n\n\t\t\t}\n\n\t\t\tout = output.length + 1;\n\t\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t\t// incrementing `n` each time, so we'll fix that now:\n\t\t\tif (floor(i / out) > maxInt - n) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tn += floor(i / out);\n\t\t\ti %= out;\n\n\t\t\t// Insert `n` at position `i` of the output\n\t\t\toutput.splice(i++, 0, n);\n\n\t\t}\n\n\t\treturn ucs2encode(output);\n\t}\n\n\t/**\n\t * Converts a string of Unicode symbols (e.g. a domain name label) to a\n\t * Punycode string of ASCII-only symbols.\n\t * @memberOf punycode\n\t * @param {String} input The string of Unicode symbols.\n\t * @returns {String} The resulting Punycode string of ASCII-only symbols.\n\t */\n\tfunction encode(input) {\n\t\tvar n,\n\t\t    delta,\n\t\t    handledCPCount,\n\t\t    basicLength,\n\t\t    bias,\n\t\t    j,\n\t\t    m,\n\t\t    q,\n\t\t    k,\n\t\t    t,\n\t\t    currentValue,\n\t\t    output = [],\n\t\t    /** `inputLength` will hold the number of code points in `input`. */\n\t\t    inputLength,\n\t\t    /** Cached calculation results */\n\t\t    handledCPCountPlusOne,\n\t\t    baseMinusT,\n\t\t    qMinusT;\n\n\t\t// Convert the input in UCS-2 to Unicode\n\t\tinput = ucs2decode(input);\n\n\t\t// Cache the length\n\t\tinputLength = input.length;\n\n\t\t// Initialize the state\n\t\tn = initialN;\n\t\tdelta = 0;\n\t\tbias = initialBias;\n\n\t\t// Handle the basic code points\n\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\tcurrentValue = input[j];\n\t\t\tif (currentValue < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t\t}\n\t\t}\n\n\t\thandledCPCount = basicLength = output.length;\n\n\t\t// `handledCPCount` is the number of code points that have been handled;\n\t\t// `basicLength` is the number of basic code points.\n\n\t\t// Finish the basic string - if it is not empty - with a delimiter\n\t\tif (basicLength) {\n\t\t\toutput.push(delimiter);\n\t\t}\n\n\t\t// Main encoding loop:\n\t\twhile (handledCPCount < inputLength) {\n\n\t\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t\t// larger one:\n\t\t\tfor (m = maxInt, j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t\t// but guard against overflow\n\t\t\thandledCPCountPlusOne = handledCPCount + 1;\n\t\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\t\tn = m;\n\n\t\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\n\t\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tif (currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer\n\t\t\t\t\tfor (q = delta, k = base; /* no condition */; k += base) {\n\t\t\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tqMinusT = q - t;\n\t\t\t\t\t\tbaseMinusT = base - t;\n\t\t\t\t\t\toutput.push(\n\t\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t\t);\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t++delta;\n\t\t\t++n;\n\n\t\t}\n\t\treturn output.join('');\n\t}\n\n\t/**\n\t * Converts a Punycode string representing a domain name or an email address\n\t * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n\t * it doesn't matter if you call it on a string that has already been\n\t * converted to Unicode.\n\t * @memberOf punycode\n\t * @param {String} input The Punycoded domain name or email address to\n\t * convert to Unicode.\n\t * @returns {String} The Unicode representation of the given Punycode\n\t * string.\n\t */\n\tfunction toUnicode(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexPunycode.test(string)\n\t\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/**\n\t * Converts a Unicode string representing a domain name or an email address to\n\t * Punycode. Only the non-ASCII parts of the domain name will be converted,\n\t * i.e. it doesn't matter if you call it with a domain that's already in\n\t * ASCII.\n\t * @memberOf punycode\n\t * @param {String} input The domain name or email address to convert, as a\n\t * Unicode string.\n\t * @returns {String} The Punycode representation of the given domain name or\n\t * email address.\n\t */\n\tfunction toASCII(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexNonASCII.test(string)\n\t\t\t\t? 'xn--' + encode(string)\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/** Define the public API */\n\tpunycode = {\n\t\t/**\n\t\t * A string representing the current Punycode.js version number.\n\t\t * @memberOf punycode\n\t\t * @type String\n\t\t */\n\t\t'version': '1.4.1',\n\t\t/**\n\t\t * An object of methods to convert from JavaScript's internal character\n\t\t * representation (UCS-2) to Unicode code points, and back.\n\t\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t\t * @memberOf punycode\n\t\t * @type Object\n\t\t */\n\t\t'ucs2': {\n\t\t\t'decode': ucs2decode,\n\t\t\t'encode': ucs2encode\n\t\t},\n\t\t'decode': decode,\n\t\t'encode': encode,\n\t\t'toASCII': toASCII,\n\t\t'toUnicode': toUnicode\n\t};\n\n\t/** Expose `punycode` */\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine('punycode', function() {\n\t\t\treturn punycode;\n\t\t});\n\t} else if (freeExports && freeModule) {\n\t\tif (module.exports == freeExports) {\n\t\t\t// in Node.js, io.js, or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = punycode;\n\t\t} else {\n\t\t\t// in Narwhal or RingoJS v0.7.0-\n\t\t\tfor (key in punycode) {\n\t\t\t\tpunycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n\t\t\t}\n\t\t}\n\t} else {\n\t\t// in Rhino or a web browser\n\t\troot.punycode = punycode;\n\t}\n\n}(this));\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n// If obj.hasOwnProperty has been overridden, then calling\n// obj.hasOwnProperty(prop) will break.\n// See: https://github.com/joyent/node/issues/1707\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nmodule.exports = function(qs, sep, eq, options) {\n  sep = sep || '&';\n  eq = eq || '=';\n  var obj = {};\n\n  if (typeof qs !== 'string' || qs.length === 0) {\n    return obj;\n  }\n\n  var regexp = /\\+/g;\n  qs = qs.split(sep);\n\n  var maxKeys = 1000;\n  if (options && typeof options.maxKeys === 'number') {\n    maxKeys = options.maxKeys;\n  }\n\n  var len = qs.length;\n  // maxKeys <= 0 means that we should not limit keys count\n  if (maxKeys > 0 && len > maxKeys) {\n    len = maxKeys;\n  }\n\n  for (var i = 0; i < len; ++i) {\n    var x = qs[i].replace(regexp, '%20'),\n        idx = x.indexOf(eq),\n        kstr, vstr, k, v;\n\n    if (idx >= 0) {\n      kstr = x.substr(0, idx);\n      vstr = x.substr(idx + 1);\n    } else {\n      kstr = x;\n      vstr = '';\n    }\n\n    k = decodeURIComponent(kstr);\n    v = decodeURIComponent(vstr);\n\n    if (!hasOwnProperty(obj, k)) {\n      obj[k] = v;\n    } else if (isArray(obj[k])) {\n      obj[k].push(v);\n    } else {\n      obj[k] = [obj[k], v];\n    }\n  }\n\n  return obj;\n};\n\nvar isArray = Array.isArray || function (xs) {\n  return Object.prototype.toString.call(xs) === '[object Array]';\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar stringifyPrimitive = function(v) {\n  switch (typeof v) {\n    case 'string':\n      return v;\n\n    case 'boolean':\n      return v ? 'true' : 'false';\n\n    case 'number':\n      return isFinite(v) ? v : '';\n\n    default:\n      return '';\n  }\n};\n\nmodule.exports = function(obj, sep, eq, name) {\n  sep = sep || '&';\n  eq = eq || '=';\n  if (obj === null) {\n    obj = undefined;\n  }\n\n  if (typeof obj === 'object') {\n    return map(objectKeys(obj), function(k) {\n      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;\n      if (isArray(obj[k])) {\n        return map(obj[k], function(v) {\n          return ks + encodeURIComponent(stringifyPrimitive(v));\n        }).join(sep);\n      } else {\n        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));\n      }\n    }).join(sep);\n\n  }\n\n  if (!name) return '';\n  return encodeURIComponent(stringifyPrimitive(name)) + eq +\n         encodeURIComponent(stringifyPrimitive(obj));\n};\n\nvar isArray = Array.isArray || function (xs) {\n  return Object.prototype.toString.call(xs) === '[object Array]';\n};\n\nfunction map (xs, f) {\n  if (xs.map) return xs.map(f);\n  var res = [];\n  for (var i = 0; i < xs.length; i++) {\n    res.push(f(xs[i], i));\n  }\n  return res;\n}\n\nvar objectKeys = Object.keys || function (obj) {\n  var res = [];\n  for (var key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);\n  }\n  return res;\n};\n","'use strict';\n\nexports.decode = exports.parse = require('./decode');\nexports.encode = exports.stringify = require('./encode');\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function define(obj, key, value) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n    return obj[key];\n  }\n  try {\n    // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n    define({}, \"\");\n  } catch (err) {\n    define = function(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  define(IteratorPrototype, iteratorSymbol, function () {\n    return this;\n  });\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = GeneratorFunctionPrototype;\n  define(Gp, \"constructor\", GeneratorFunctionPrototype);\n  define(GeneratorFunctionPrototype, \"constructor\", GeneratorFunction);\n  GeneratorFunction.displayName = define(\n    GeneratorFunctionPrototype,\n    toStringTagSymbol,\n    \"GeneratorFunction\"\n  );\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      define(prototype, method, function(arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  define(AsyncIterator.prototype, asyncIteratorSymbol, function () {\n    return this;\n  });\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  define(Gp, toStringTagSymbol, \"Generator\");\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  define(Gp, iteratorSymbol, function() {\n    return this;\n  });\n\n  define(Gp, \"toString\", function() {\n    return \"[object Generator]\";\n  });\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, in modern engines\n  // we can explicitly access globalThis. In older engines we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  if (typeof globalThis === \"object\") {\n    globalThis.regeneratorRuntime = runtime;\n  } else {\n    Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n  }\n}\n","/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\n/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.prototype = Object.create(Buffer.prototype)\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","var ClientRequest = require('./lib/request')\nvar response = require('./lib/response')\nvar extend = require('xtend')\nvar statusCodes = require('builtin-status-codes')\nvar url = require('url')\n\nvar http = exports\n\nhttp.request = function (opts, cb) {\n\tif (typeof opts === 'string')\n\t\topts = url.parse(opts)\n\telse\n\t\topts = extend(opts)\n\n\t// Normally, the page is loaded from http or https, so not specifying a protocol\n\t// will result in a (valid) protocol-relative url. However, this won't work if\n\t// the protocol is something else, like 'file:'\n\tvar defaultProtocol = global.location.protocol.search(/^https?:$/) === -1 ? 'http:' : ''\n\n\tvar protocol = opts.protocol || defaultProtocol\n\tvar host = opts.hostname || opts.host\n\tvar port = opts.port\n\tvar path = opts.path || '/'\n\n\t// Necessary for IPv6 addresses\n\tif (host && host.indexOf(':') !== -1)\n\t\thost = '[' + host + ']'\n\n\t// This may be a relative url. The browser should always be able to interpret it correctly.\n\topts.url = (host ? (protocol + '//' + host) : '') + (port ? ':' + port : '') + path\n\topts.method = (opts.method || 'GET').toUpperCase()\n\topts.headers = opts.headers || {}\n\n\t// Also valid opts.auth, opts.mode\n\n\tvar req = new ClientRequest(opts)\n\tif (cb)\n\t\treq.on('response', cb)\n\treturn req\n}\n\nhttp.get = function get (opts, cb) {\n\tvar req = http.request(opts, cb)\n\treq.end()\n\treturn req\n}\n\nhttp.ClientRequest = ClientRequest\nhttp.IncomingMessage = response.IncomingMessage\n\nhttp.Agent = function () {}\nhttp.Agent.defaultMaxSockets = 4\n\nhttp.globalAgent = new http.Agent()\n\nhttp.STATUS_CODES = statusCodes\n\nhttp.METHODS = [\n\t'CHECKOUT',\n\t'CONNECT',\n\t'COPY',\n\t'DELETE',\n\t'GET',\n\t'HEAD',\n\t'LOCK',\n\t'M-SEARCH',\n\t'MERGE',\n\t'MKACTIVITY',\n\t'MKCOL',\n\t'MOVE',\n\t'NOTIFY',\n\t'OPTIONS',\n\t'PATCH',\n\t'POST',\n\t'PROPFIND',\n\t'PROPPATCH',\n\t'PURGE',\n\t'PUT',\n\t'REPORT',\n\t'SEARCH',\n\t'SUBSCRIBE',\n\t'TRACE',\n\t'UNLOCK',\n\t'UNSUBSCRIBE'\n]","exports.fetch = isFunction(global.fetch) && isFunction(global.ReadableStream)\n\nexports.writableStream = isFunction(global.WritableStream)\n\nexports.abortController = isFunction(global.AbortController)\n\n// The xhr request to example.com may violate some restrictive CSP configurations,\n// so if we're running in a browser that supports `fetch`, avoid calling getXHR()\n// and assume support for certain features below.\nvar xhr\nfunction getXHR () {\n\t// Cache the xhr value\n\tif (xhr !== undefined) return xhr\n\n\tif (global.XMLHttpRequest) {\n\t\txhr = new global.XMLHttpRequest()\n\t\t// If XDomainRequest is available (ie only, where xhr might not work\n\t\t// cross domain), use the page location. Otherwise use example.com\n\t\t// Note: this doesn't actually make an http request.\n\t\ttry {\n\t\t\txhr.open('GET', global.XDomainRequest ? '/' : 'https://example.com')\n\t\t} catch(e) {\n\t\t\txhr = null\n\t\t}\n\t} else {\n\t\t// Service workers don't have XHR\n\t\txhr = null\n\t}\n\treturn xhr\n}\n\nfunction checkTypeSupport (type) {\n\tvar xhr = getXHR()\n\tif (!xhr) return false\n\ttry {\n\t\txhr.responseType = type\n\t\treturn xhr.responseType === type\n\t} catch (e) {}\n\treturn false\n}\n\n// If fetch is supported, then arraybuffer will be supported too. Skip calling\n// checkTypeSupport(), since that calls getXHR().\nexports.arraybuffer = exports.fetch || checkTypeSupport('arraybuffer')\n\n// These next two tests unavoidably show warnings in Chrome. Since fetch will always\n// be used if it's available, just return false for these to avoid the warnings.\nexports.msstream = !exports.fetch && checkTypeSupport('ms-stream')\nexports.mozchunkedarraybuffer = !exports.fetch && checkTypeSupport('moz-chunked-arraybuffer')\n\n// If fetch is supported, then overrideMimeType will be supported too. Skip calling\n// getXHR().\nexports.overrideMimeType = exports.fetch || (getXHR() ? isFunction(getXHR().overrideMimeType) : false)\n\nfunction isFunction (value) {\n\treturn typeof value === 'function'\n}\n\nxhr = null // Help gc\n","var capability = require('./capability')\nvar inherits = require('inherits')\nvar response = require('./response')\nvar stream = require('readable-stream')\n\nvar IncomingMessage = response.IncomingMessage\nvar rStates = response.readyStates\n\nfunction decideMode (preferBinary, useFetch) {\n\tif (capability.fetch && useFetch) {\n\t\treturn 'fetch'\n\t} else if (capability.mozchunkedarraybuffer) {\n\t\treturn 'moz-chunked-arraybuffer'\n\t} else if (capability.msstream) {\n\t\treturn 'ms-stream'\n\t} else if (capability.arraybuffer && preferBinary) {\n\t\treturn 'arraybuffer'\n\t} else {\n\t\treturn 'text'\n\t}\n}\n\nvar ClientRequest = module.exports = function (opts) {\n\tvar self = this\n\tstream.Writable.call(self)\n\n\tself._opts = opts\n\tself._body = []\n\tself._headers = {}\n\tif (opts.auth)\n\t\tself.setHeader('Authorization', 'Basic ' + Buffer.from(opts.auth).toString('base64'))\n\tObject.keys(opts.headers).forEach(function (name) {\n\t\tself.setHeader(name, opts.headers[name])\n\t})\n\n\tvar preferBinary\n\tvar useFetch = true\n\tif (opts.mode === 'disable-fetch' || ('requestTimeout' in opts && !capability.abortController)) {\n\t\t// If the use of XHR should be preferred. Not typically needed.\n\t\tuseFetch = false\n\t\tpreferBinary = true\n\t} else if (opts.mode === 'prefer-streaming') {\n\t\t// If streaming is a high priority but binary compatibility and\n\t\t// the accuracy of the 'content-type' header aren't\n\t\tpreferBinary = false\n\t} else if (opts.mode === 'allow-wrong-content-type') {\n\t\t// If streaming is more important than preserving the 'content-type' header\n\t\tpreferBinary = !capability.overrideMimeType\n\t} else if (!opts.mode || opts.mode === 'default' || opts.mode === 'prefer-fast') {\n\t\t// Use binary if text streaming may corrupt data or the content-type header, or for speed\n\t\tpreferBinary = true\n\t} else {\n\t\tthrow new Error('Invalid value for opts.mode')\n\t}\n\tself._mode = decideMode(preferBinary, useFetch)\n\tself._fetchTimer = null\n\tself._socketTimeout = null\n\tself._socketTimer = null\n\n\tself.on('finish', function () {\n\t\tself._onFinish()\n\t})\n}\n\ninherits(ClientRequest, stream.Writable)\n\nClientRequest.prototype.setHeader = function (name, value) {\n\tvar self = this\n\tvar lowerName = name.toLowerCase()\n\t// This check is not necessary, but it prevents warnings from browsers about setting unsafe\n\t// headers. To be honest I'm not entirely sure hiding these warnings is a good thing, but\n\t// http-browserify did it, so I will too.\n\tif (unsafeHeaders.indexOf(lowerName) !== -1)\n\t\treturn\n\n\tself._headers[lowerName] = {\n\t\tname: name,\n\t\tvalue: value\n\t}\n}\n\nClientRequest.prototype.getHeader = function (name) {\n\tvar header = this._headers[name.toLowerCase()]\n\tif (header)\n\t\treturn header.value\n\treturn null\n}\n\nClientRequest.prototype.removeHeader = function (name) {\n\tvar self = this\n\tdelete self._headers[name.toLowerCase()]\n}\n\nClientRequest.prototype._onFinish = function () {\n\tvar self = this\n\n\tif (self._destroyed)\n\t\treturn\n\tvar opts = self._opts\n\n\tif ('timeout' in opts && opts.timeout !== 0) {\n\t\tself.setTimeout(opts.timeout)\n\t}\n\n\tvar headersObj = self._headers\n\tvar body = null\n\tif (opts.method !== 'GET' && opts.method !== 'HEAD') {\n        body = new Blob(self._body, {\n            type: (headersObj['content-type'] || {}).value || ''\n        });\n    }\n\n\t// create flattened list of headers\n\tvar headersList = []\n\tObject.keys(headersObj).forEach(function (keyName) {\n\t\tvar name = headersObj[keyName].name\n\t\tvar value = headersObj[keyName].value\n\t\tif (Array.isArray(value)) {\n\t\t\tvalue.forEach(function (v) {\n\t\t\t\theadersList.push([name, v])\n\t\t\t})\n\t\t} else {\n\t\t\theadersList.push([name, value])\n\t\t}\n\t})\n\n\tif (self._mode === 'fetch') {\n\t\tvar signal = null\n\t\tif (capability.abortController) {\n\t\t\tvar controller = new AbortController()\n\t\t\tsignal = controller.signal\n\t\t\tself._fetchAbortController = controller\n\n\t\t\tif ('requestTimeout' in opts && opts.requestTimeout !== 0) {\n\t\t\t\tself._fetchTimer = global.setTimeout(function () {\n\t\t\t\t\tself.emit('requestTimeout')\n\t\t\t\t\tif (self._fetchAbortController)\n\t\t\t\t\t\tself._fetchAbortController.abort()\n\t\t\t\t}, opts.requestTimeout)\n\t\t\t}\n\t\t}\n\n\t\tglobal.fetch(self._opts.url, {\n\t\t\tmethod: self._opts.method,\n\t\t\theaders: headersList,\n\t\t\tbody: body || undefined,\n\t\t\tmode: 'cors',\n\t\t\tcredentials: opts.withCredentials ? 'include' : 'same-origin',\n\t\t\tsignal: signal\n\t\t}).then(function (response) {\n\t\t\tself._fetchResponse = response\n\t\t\tself._resetTimers(false)\n\t\t\tself._connect()\n\t\t}, function (reason) {\n\t\t\tself._resetTimers(true)\n\t\t\tif (!self._destroyed)\n\t\t\t\tself.emit('error', reason)\n\t\t})\n\t} else {\n\t\tvar xhr = self._xhr = new global.XMLHttpRequest()\n\t\ttry {\n\t\t\txhr.open(self._opts.method, self._opts.url, true)\n\t\t} catch (err) {\n\t\t\tprocess.nextTick(function () {\n\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t\treturn\n\t\t}\n\n\t\t// Can't set responseType on really old browsers\n\t\tif ('responseType' in xhr)\n\t\t\txhr.responseType = self._mode\n\n\t\tif ('withCredentials' in xhr)\n\t\t\txhr.withCredentials = !!opts.withCredentials\n\n\t\tif (self._mode === 'text' && 'overrideMimeType' in xhr)\n\t\t\txhr.overrideMimeType('text/plain; charset=x-user-defined')\n\n\t\tif ('requestTimeout' in opts) {\n\t\t\txhr.timeout = opts.requestTimeout\n\t\t\txhr.ontimeout = function () {\n\t\t\t\tself.emit('requestTimeout')\n\t\t\t}\n\t\t}\n\n\t\theadersList.forEach(function (header) {\n\t\t\txhr.setRequestHeader(header[0], header[1])\n\t\t})\n\n\t\tself._response = null\n\t\txhr.onreadystatechange = function () {\n\t\t\tswitch (xhr.readyState) {\n\t\t\t\tcase rStates.LOADING:\n\t\t\t\tcase rStates.DONE:\n\t\t\t\t\tself._onXHRProgress()\n\t\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t\t// Necessary for streaming in Firefox, since xhr.response is ONLY defined\n\t\t// in onprogress, not in onreadystatechange with xhr.readyState = 3\n\t\tif (self._mode === 'moz-chunked-arraybuffer') {\n\t\t\txhr.onprogress = function () {\n\t\t\t\tself._onXHRProgress()\n\t\t\t}\n\t\t}\n\n\t\txhr.onerror = function () {\n\t\t\tif (self._destroyed)\n\t\t\t\treturn\n\t\t\tself._resetTimers(true)\n\t\t\tself.emit('error', new Error('XHR error'))\n\t\t}\n\n\t\ttry {\n\t\t\txhr.send(body)\n\t\t} catch (err) {\n\t\t\tprocess.nextTick(function () {\n\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t\treturn\n\t\t}\n\t}\n}\n\n/**\n * Checks if xhr.status is readable and non-zero, indicating no error.\n * Even though the spec says it should be available in readyState 3,\n * accessing it throws an exception in IE8\n */\nfunction statusValid (xhr) {\n\ttry {\n\t\tvar status = xhr.status\n\t\treturn (status !== null && status !== 0)\n\t} catch (e) {\n\t\treturn false\n\t}\n}\n\nClientRequest.prototype._onXHRProgress = function () {\n\tvar self = this\n\n\tself._resetTimers(false)\n\n\tif (!statusValid(self._xhr) || self._destroyed)\n\t\treturn\n\n\tif (!self._response)\n\t\tself._connect()\n\n\tself._response._onXHRProgress(self._resetTimers.bind(self))\n}\n\nClientRequest.prototype._connect = function () {\n\tvar self = this\n\n\tif (self._destroyed)\n\t\treturn\n\n\tself._response = new IncomingMessage(self._xhr, self._fetchResponse, self._mode, self._resetTimers.bind(self))\n\tself._response.on('error', function(err) {\n\t\tself.emit('error', err)\n\t})\n\n\tself.emit('response', self._response)\n}\n\nClientRequest.prototype._write = function (chunk, encoding, cb) {\n\tvar self = this\n\n\tself._body.push(chunk)\n\tcb()\n}\n\nClientRequest.prototype._resetTimers = function (done) {\n\tvar self = this\n\n\tglobal.clearTimeout(self._socketTimer)\n\tself._socketTimer = null\n\n\tif (done) {\n\t\tglobal.clearTimeout(self._fetchTimer)\n\t\tself._fetchTimer = null\n\t} else if (self._socketTimeout) {\n\t\tself._socketTimer = global.setTimeout(function () {\n\t\t\tself.emit('timeout')\n\t\t}, self._socketTimeout)\n\t}\n}\n\nClientRequest.prototype.abort = ClientRequest.prototype.destroy = function (err) {\n\tvar self = this\n\tself._destroyed = true\n\tself._resetTimers(true)\n\tif (self._response)\n\t\tself._response._destroyed = true\n\tif (self._xhr)\n\t\tself._xhr.abort()\n\telse if (self._fetchAbortController)\n\t\tself._fetchAbortController.abort()\n\n\tif (err)\n\t\tself.emit('error', err)\n}\n\nClientRequest.prototype.end = function (data, encoding, cb) {\n\tvar self = this\n\tif (typeof data === 'function') {\n\t\tcb = data\n\t\tdata = undefined\n\t}\n\n\tstream.Writable.prototype.end.call(self, data, encoding, cb)\n}\n\nClientRequest.prototype.setTimeout = function (timeout, cb) {\n\tvar self = this\n\n\tif (cb)\n\t\tself.once('timeout', cb)\n\n\tself._socketTimeout = timeout\n\tself._resetTimers(false)\n}\n\nClientRequest.prototype.flushHeaders = function () {}\nClientRequest.prototype.setNoDelay = function () {}\nClientRequest.prototype.setSocketKeepAlive = function () {}\n\n// Taken from http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader%28%29-method\nvar unsafeHeaders = [\n\t'accept-charset',\n\t'accept-encoding',\n\t'access-control-request-headers',\n\t'access-control-request-method',\n\t'connection',\n\t'content-length',\n\t'cookie',\n\t'cookie2',\n\t'date',\n\t'dnt',\n\t'expect',\n\t'host',\n\t'keep-alive',\n\t'origin',\n\t'referer',\n\t'te',\n\t'trailer',\n\t'transfer-encoding',\n\t'upgrade',\n\t'via'\n]\n","var capability = require('./capability')\nvar inherits = require('inherits')\nvar stream = require('readable-stream')\n\nvar rStates = exports.readyStates = {\n\tUNSENT: 0,\n\tOPENED: 1,\n\tHEADERS_RECEIVED: 2,\n\tLOADING: 3,\n\tDONE: 4\n}\n\nvar IncomingMessage = exports.IncomingMessage = function (xhr, response, mode, resetTimers) {\n\tvar self = this\n\tstream.Readable.call(self)\n\n\tself._mode = mode\n\tself.headers = {}\n\tself.rawHeaders = []\n\tself.trailers = {}\n\tself.rawTrailers = []\n\n\t// Fake the 'close' event, but only once 'end' fires\n\tself.on('end', function () {\n\t\t// The nextTick is necessary to prevent the 'request' module from causing an infinite loop\n\t\tprocess.nextTick(function () {\n\t\t\tself.emit('close')\n\t\t})\n\t})\n\n\tif (mode === 'fetch') {\n\t\tself._fetchResponse = response\n\n\t\tself.url = response.url\n\t\tself.statusCode = response.status\n\t\tself.statusMessage = response.statusText\n\t\t\n\t\tresponse.headers.forEach(function (header, key){\n\t\t\tself.headers[key.toLowerCase()] = header\n\t\t\tself.rawHeaders.push(key, header)\n\t\t})\n\n\t\tif (capability.writableStream) {\n\t\t\tvar writable = new WritableStream({\n\t\t\t\twrite: function (chunk) {\n\t\t\t\t\tresetTimers(false)\n\t\t\t\t\treturn new Promise(function (resolve, reject) {\n\t\t\t\t\t\tif (self._destroyed) {\n\t\t\t\t\t\t\treject()\n\t\t\t\t\t\t} else if(self.push(Buffer.from(chunk))) {\n\t\t\t\t\t\t\tresolve()\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tself._resumeFetch = resolve\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t\t\t},\n\t\t\t\tclose: function () {\n\t\t\t\t\tresetTimers(true)\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.push(null)\n\t\t\t\t},\n\t\t\t\tabort: function (err) {\n\t\t\t\t\tresetTimers(true)\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.emit('error', err)\n\t\t\t\t}\n\t\t\t})\n\n\t\t\ttry {\n\t\t\t\tresponse.body.pipeTo(writable).catch(function (err) {\n\t\t\t\t\tresetTimers(true)\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.emit('error', err)\n\t\t\t\t})\n\t\t\t\treturn\n\t\t\t} catch (e) {} // pipeTo method isn't defined. Can't find a better way to feature test this\n\t\t}\n\t\t// fallback for when writableStream or pipeTo aren't available\n\t\tvar reader = response.body.getReader()\n\t\tfunction read () {\n\t\t\treader.read().then(function (result) {\n\t\t\t\tif (self._destroyed)\n\t\t\t\t\treturn\n\t\t\t\tresetTimers(result.done)\n\t\t\t\tif (result.done) {\n\t\t\t\t\tself.push(null)\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t\tself.push(Buffer.from(result.value))\n\t\t\t\tread()\n\t\t\t}).catch(function (err) {\n\t\t\t\tresetTimers(true)\n\t\t\t\tif (!self._destroyed)\n\t\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t}\n\t\tread()\n\t} else {\n\t\tself._xhr = xhr\n\t\tself._pos = 0\n\n\t\tself.url = xhr.responseURL\n\t\tself.statusCode = xhr.status\n\t\tself.statusMessage = xhr.statusText\n\t\tvar headers = xhr.getAllResponseHeaders().split(/\\r?\\n/)\n\t\theaders.forEach(function (header) {\n\t\t\tvar matches = header.match(/^([^:]+):\\s*(.*)/)\n\t\t\tif (matches) {\n\t\t\t\tvar key = matches[1].toLowerCase()\n\t\t\t\tif (key === 'set-cookie') {\n\t\t\t\t\tif (self.headers[key] === undefined) {\n\t\t\t\t\t\tself.headers[key] = []\n\t\t\t\t\t}\n\t\t\t\t\tself.headers[key].push(matches[2])\n\t\t\t\t} else if (self.headers[key] !== undefined) {\n\t\t\t\t\tself.headers[key] += ', ' + matches[2]\n\t\t\t\t} else {\n\t\t\t\t\tself.headers[key] = matches[2]\n\t\t\t\t}\n\t\t\t\tself.rawHeaders.push(matches[1], matches[2])\n\t\t\t}\n\t\t})\n\n\t\tself._charset = 'x-user-defined'\n\t\tif (!capability.overrideMimeType) {\n\t\t\tvar mimeType = self.rawHeaders['mime-type']\n\t\t\tif (mimeType) {\n\t\t\t\tvar charsetMatch = mimeType.match(/;\\s*charset=([^;])(;|$)/)\n\t\t\t\tif (charsetMatch) {\n\t\t\t\t\tself._charset = charsetMatch[1].toLowerCase()\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (!self._charset)\n\t\t\t\tself._charset = 'utf-8' // best guess\n\t\t}\n\t}\n}\n\ninherits(IncomingMessage, stream.Readable)\n\nIncomingMessage.prototype._read = function () {\n\tvar self = this\n\n\tvar resolve = self._resumeFetch\n\tif (resolve) {\n\t\tself._resumeFetch = null\n\t\tresolve()\n\t}\n}\n\nIncomingMessage.prototype._onXHRProgress = function (resetTimers) {\n\tvar self = this\n\n\tvar xhr = self._xhr\n\n\tvar response = null\n\tswitch (self._mode) {\n\t\tcase 'text':\n\t\t\tresponse = xhr.responseText\n\t\t\tif (response.length > self._pos) {\n\t\t\t\tvar newData = response.substr(self._pos)\n\t\t\t\tif (self._charset === 'x-user-defined') {\n\t\t\t\t\tvar buffer = Buffer.alloc(newData.length)\n\t\t\t\t\tfor (var i = 0; i < newData.length; i++)\n\t\t\t\t\t\tbuffer[i] = newData.charCodeAt(i) & 0xff\n\n\t\t\t\t\tself.push(buffer)\n\t\t\t\t} else {\n\t\t\t\t\tself.push(newData, self._charset)\n\t\t\t\t}\n\t\t\t\tself._pos = response.length\n\t\t\t}\n\t\t\tbreak\n\t\tcase 'arraybuffer':\n\t\t\tif (xhr.readyState !== rStates.DONE || !xhr.response)\n\t\t\t\tbreak\n\t\t\tresponse = xhr.response\n\t\t\tself.push(Buffer.from(new Uint8Array(response)))\n\t\t\tbreak\n\t\tcase 'moz-chunked-arraybuffer': // take whole\n\t\t\tresponse = xhr.response\n\t\t\tif (xhr.readyState !== rStates.LOADING || !response)\n\t\t\t\tbreak\n\t\t\tself.push(Buffer.from(new Uint8Array(response)))\n\t\t\tbreak\n\t\tcase 'ms-stream':\n\t\t\tresponse = xhr.response\n\t\t\tif (xhr.readyState !== rStates.LOADING)\n\t\t\t\tbreak\n\t\t\tvar reader = new global.MSStreamReader()\n\t\t\treader.onprogress = function () {\n\t\t\t\tif (reader.result.byteLength > self._pos) {\n\t\t\t\t\tself.push(Buffer.from(new Uint8Array(reader.result.slice(self._pos))))\n\t\t\t\t\tself._pos = reader.result.byteLength\n\t\t\t\t}\n\t\t\t}\n\t\t\treader.onload = function () {\n\t\t\t\tresetTimers(true)\n\t\t\t\tself.push(null)\n\t\t\t}\n\t\t\t// reader.onerror = ??? // TODO: this\n\t\t\treader.readAsArrayBuffer(response)\n\t\t\tbreak\n\t}\n\n\t// The ms-stream case handles end separately in reader.onload()\n\tif (self._xhr.readyState === rStates.DONE && self._mode !== 'ms-stream') {\n\t\tresetTimers(true)\n\t\tself.push(null)\n\t}\n}\n","'use strict';\n\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }\n\nvar codes = {};\n\nfunction createErrorType(code, message, Base) {\n  if (!Base) {\n    Base = Error;\n  }\n\n  function getMessage(arg1, arg2, arg3) {\n    if (typeof message === 'string') {\n      return message;\n    } else {\n      return message(arg1, arg2, arg3);\n    }\n  }\n\n  var NodeError =\n  /*#__PURE__*/\n  function (_Base) {\n    _inheritsLoose(NodeError, _Base);\n\n    function NodeError(arg1, arg2, arg3) {\n      return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;\n    }\n\n    return NodeError;\n  }(Base);\n\n  NodeError.prototype.name = Base.name;\n  NodeError.prototype.code = code;\n  codes[code] = NodeError;\n} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js\n\n\nfunction oneOf(expected, thing) {\n  if (Array.isArray(expected)) {\n    var len = expected.length;\n    expected = expected.map(function (i) {\n      return String(i);\n    });\n\n    if (len > 2) {\n      return \"one of \".concat(thing, \" \").concat(expected.slice(0, len - 1).join(', '), \", or \") + expected[len - 1];\n    } else if (len === 2) {\n      return \"one of \".concat(thing, \" \").concat(expected[0], \" or \").concat(expected[1]);\n    } else {\n      return \"of \".concat(thing, \" \").concat(expected[0]);\n    }\n  } else {\n    return \"of \".concat(thing, \" \").concat(String(expected));\n  }\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith\n\n\nfunction startsWith(str, search, pos) {\n  return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith\n\n\nfunction endsWith(str, search, this_len) {\n  if (this_len === undefined || this_len > str.length) {\n    this_len = str.length;\n  }\n\n  return str.substring(this_len - search.length, this_len) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes\n\n\nfunction includes(str, search, start) {\n  if (typeof start !== 'number') {\n    start = 0;\n  }\n\n  if (start + search.length > str.length) {\n    return false;\n  } else {\n    return str.indexOf(search, start) !== -1;\n  }\n}\n\ncreateErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {\n  return 'The value \"' + value + '\" is invalid for option \"' + name + '\"';\n}, TypeError);\ncreateErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {\n  // determiner: 'must be' or 'must not be'\n  var determiner;\n\n  if (typeof expected === 'string' && startsWith(expected, 'not ')) {\n    determiner = 'must not be';\n    expected = expected.replace(/^not /, '');\n  } else {\n    determiner = 'must be';\n  }\n\n  var msg;\n\n  if (endsWith(name, ' argument')) {\n    // For cases like 'first argument'\n    msg = \"The \".concat(name, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n  } else {\n    var type = includes(name, '.') ? 'property' : 'argument';\n    msg = \"The \\\"\".concat(name, \"\\\" \").concat(type, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n  }\n\n  msg += \". Received type \".concat(typeof actual);\n  return msg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');\ncreateErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {\n  return 'The ' + name + ' method is not implemented';\n});\ncreateErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');\ncreateErrorType('ERR_STREAM_DESTROYED', function (name) {\n  return 'Cannot call ' + name + ' after a stream was destroyed';\n});\ncreateErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');\ncreateErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');\ncreateErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');\ncreateErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);\ncreateErrorType('ERR_UNKNOWN_ENCODING', function (arg) {\n  return 'Unknown encoding: ' + arg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');\nmodule.exports.codes = codes;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n'use strict';\n/*<replacement>*/\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n\n  for (var key in obj) {\n    keys.push(key);\n  }\n\n  return keys;\n};\n/*</replacement>*/\n\n\nmodule.exports = Duplex;\n\nvar Readable = require('./_stream_readable');\n\nvar Writable = require('./_stream_writable');\n\nrequire('inherits')(Duplex, Readable);\n\n{\n  // Allow the keys array to be GC'ed.\n  var keys = objectKeys(Writable.prototype);\n\n  for (var v = 0; v < keys.length; v++) {\n    var method = keys[v];\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n  }\n}\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n  Readable.call(this, options);\n  Writable.call(this, options);\n  this.allowHalfOpen = true;\n\n  if (options) {\n    if (options.readable === false) this.readable = false;\n    if (options.writable === false) this.writable = false;\n\n    if (options.allowHalfOpen === false) {\n      this.allowHalfOpen = false;\n      this.once('end', onend);\n    }\n  }\n}\n\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.highWaterMark;\n  }\n});\nObject.defineProperty(Duplex.prototype, 'writableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState && this._writableState.getBuffer();\n  }\n});\nObject.defineProperty(Duplex.prototype, 'writableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.length;\n  }\n}); // the no-half-open enforcer\n\nfunction onend() {\n  // If the writable side ended, then we're ok.\n  if (this._writableState.ended) return; // no more data can be written.\n  // But allow more writes to happen in this tick.\n\n  process.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\nrequire('inherits')(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n'use strict';\n\nmodule.exports = Readable;\n/*<replacement>*/\n\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n/*<replacement>*/\n\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function EElistenerCount(emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\n\n\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/*<replacement>*/\n\n\nvar debugUtil = require('util');\n\nvar debug;\n\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function debug() {};\n}\n/*</replacement>*/\n\n\nvar BufferList = require('./internal/streams/buffer_list');\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n    getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n    ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n    ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,\n    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n    ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT; // Lazy loaded to improve the startup performance.\n\n\nvar StringDecoder;\nvar createReadableStreamAsyncIterator;\nvar from;\n\nrequire('inherits')(Readable, Stream);\n\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n\n  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\n\nfunction ReadableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {}; // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n\n  this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false; // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n\n  this.sync = true; // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n  this.paused = true; // Should close be emitted on destroy. Defaults to true.\n\n  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish')\n\n  this.autoDestroy = !!options.autoDestroy; // has it been destroyed\n\n  this.destroyed = false; // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n\n  this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s\n\n  this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled\n\n  this.readingMore = false;\n  this.decoder = null;\n  this.encoding = null;\n\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n  if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the ReadableState constructor, at least with V8 6.5\n\n  var isDuplex = this instanceof Duplex;\n  this._readableState = new ReadableState(options, this, isDuplex); // legacy\n\n  this.readable = true;\n\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n\n  Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._readableState === undefined) {\n      return false;\n    }\n\n    return this._readableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._readableState.destroyed = value;\n  }\n});\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\n\nReadable.prototype._destroy = function (err, cb) {\n  cb(err);\n}; // Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\n\n\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n}; // Unshift should *always* be something directly out of read()\n\n\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  debug('readableAddChunk', chunk);\n  var state = stream._readableState;\n\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n\n    if (er) {\n      errorOrDestroy(stream, er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n\n      if (addToFront) {\n        if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());\n      } else if (state.destroyed) {\n        return false;\n      } else {\n        state.reading = false;\n\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n      maybeReadMore(stream, state);\n    }\n  } // We can push more data if we are below the highWaterMark.\n  // Also, if we have no data yet, we can stand some more bytes.\n  // This is to work around cases where hwm=0, such as the repl.\n\n\n  return !state.ended && (state.length < state.highWaterMark || state.length === 0);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    state.awaitDrain = 0;\n    stream.emit('data', chunk);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n    if (state.needReadable) emitReadable(stream);\n  }\n\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);\n  }\n\n  return er;\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n}; // backwards compatibility.\n\n\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  var decoder = new StringDecoder(enc);\n  this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8\n\n  this._readableState.encoding = this._readableState.decoder.encoding; // Iterate over current buffer to convert already stored Buffers:\n\n  var p = this._readableState.buffer.head;\n  var content = '';\n\n  while (p !== null) {\n    content += decoder.write(p.data);\n    p = p.next;\n  }\n\n  this._readableState.buffer.clear();\n\n  if (content !== '') this._readableState.buffer.push(content);\n  this._readableState.length = content.length;\n  return this;\n}; // Don't raise the hwm > 1GB\n\n\nvar MAX_HWM = 0x40000000;\n\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n\n  return n;\n} // This function is designed to be inlinable, so please take care when making\n// changes to the function body.\n\n\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  } // If we're asking for more than the current hwm, then raise the hwm.\n\n\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n; // Don't have enough\n\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n\n  return state.length;\n} // you can override either this method, or the async _read(n) below.\n\n\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n  if (n !== 0) state.emittedReadable = false; // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n\n  if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up.\n\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  } // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n  // if we need a readable event, then we need to do some reading.\n\n\n  var doRead = state.needReadable;\n  debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some\n\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  } // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n\n\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true; // if the length is currently zero, then we *need* a readable event.\n\n    if (state.length === 0) state.needReadable = true; // call internal read method\n\n    this._read(state.highWaterMark);\n\n    state.sync = false; // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = state.length <= state.highWaterMark;\n    n = 0;\n  } else {\n    state.length -= n;\n    state.awaitDrain = 0;\n  }\n\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true; // If we tried to read() past the EOF, then emit end on the next tick.\n\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  debug('onEofChunk');\n  if (state.ended) return;\n\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n\n  state.ended = true;\n\n  if (state.sync) {\n    // if we are sync, wait until next tick to emit the data.\n    // Otherwise we risk emitting data in the flow()\n    // the readable code triggers during a read() call\n    emitReadable(stream);\n  } else {\n    // emit 'readable' now to make sure it gets picked up.\n    state.needReadable = false;\n\n    if (!state.emittedReadable) {\n      state.emittedReadable = true;\n      emitReadable_(stream);\n    }\n  }\n} // Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\n\n\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  debug('emitReadable', state.needReadable, state.emittedReadable);\n  state.needReadable = false;\n\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    process.nextTick(emitReadable_, stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  var state = stream._readableState;\n  debug('emitReadable_', state.destroyed, state.length, state.ended);\n\n  if (!state.destroyed && (state.length || state.ended)) {\n    stream.emit('readable');\n    state.emittedReadable = false;\n  } // The stream needs another readable event if\n  // 1. It is not flowing, as the flow mechanism will take\n  //    care of it.\n  // 2. It is not ended.\n  // 3. It is below the highWaterMark, so we can schedule\n  //    another readable later.\n\n\n  state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;\n  flow(stream);\n} // at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\n\n\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    process.nextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  // Attempt to read more data if we should.\n  //\n  // The conditions for reading more data are (one of):\n  // - Not enough data buffered (state.length < state.highWaterMark). The loop\n  //   is responsible for filling the buffer with enough data if such data\n  //   is available. If highWaterMark is 0 and we are not in the flowing mode\n  //   we should _not_ attempt to buffer any extra data. We'll get more data\n  //   when the stream consumer calls read() instead.\n  // - No data in the buffer, and the stream is in flowing mode. In this mode\n  //   the loop below is responsible for ensuring read() is called. Failing to\n  //   call read here would abort the flow and there's no other mechanism for\n  //   continuing the flow if the stream consumer has just subscribed to the\n  //   'data' event.\n  //\n  // In addition to the above conditions to keep reading data, the following\n  // conditions prevent the data from being read:\n  // - The stream has ended (state.ended).\n  // - There is already a pending 'read' operation (state.reading). This is a\n  //   case where the the stream has called the implementation defined _read()\n  //   method, but they are processing the call asynchronously and have _not_\n  //   called push() with new data. In this case we skip performing more\n  //   read()s. The execution ends in this method again after the _read() ends\n  //   up calling push() with more data.\n  while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {\n    var len = state.length;\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length) // didn't get any data, stop spinning.\n      break;\n  }\n\n  state.readingMore = false;\n} // abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\n\n\nReadable.prototype._read = function (n) {\n  errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);\n  dest.on('unpipe', onunpipe);\n\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  } // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n\n\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n  var cleanedUp = false;\n\n  function cleanup() {\n    debug('cleanup'); // cleanup event handlers once the pipe is broken\n\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n    cleanedUp = true; // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  src.on('data', ondata);\n\n  function ondata(chunk) {\n    debug('ondata');\n    var ret = dest.write(chunk);\n    debug('dest.write', ret);\n\n    if (ret === false) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', state.awaitDrain);\n        state.awaitDrain++;\n      }\n\n      src.pause();\n    }\n  } // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n\n\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er);\n  } // Make sure our error handler is attached before userland ones.\n\n\n  prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once.\n\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n\n  dest.once('close', onclose);\n\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  } // tell the dest that it's being piped to\n\n\n  dest.emit('pipe', src); // start the flow if it hasn't been started already.\n\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function pipeOnDrainFunctionResult() {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = {\n    hasUnpiped: false\n  }; // if we're not piping anywhere, then do nothing.\n\n  if (state.pipesCount === 0) return this; // just one destination.  most common case.\n\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n    if (!dest) dest = state.pipes; // got a match.\n\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  } // slow case. multiple pipe destinations.\n\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, {\n        hasUnpiped: false\n      });\n    }\n\n    return this;\n  } // try to find the right one.\n\n\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n  dest.emit('unpipe', this, unpipeInfo);\n  return this;\n}; // set up data events if they are asked for\n// Ensure readable listeners eventually get something\n\n\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n  var state = this._readableState;\n\n  if (ev === 'data') {\n    // update readableListening so that resume() may be a no-op\n    // a few lines down. This is needed to support once('readable').\n    state.readableListening = this.listenerCount('readable') > 0; // Try start flowing on next tick if stream isn't explicitly paused\n\n    if (state.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.flowing = false;\n      state.emittedReadable = false;\n      debug('on readable', state.length, state.reading);\n\n      if (state.length) {\n        emitReadable(this);\n      } else if (!state.reading) {\n        process.nextTick(nReadingNextTick, this);\n      }\n    }\n  }\n\n  return res;\n};\n\nReadable.prototype.addListener = Readable.prototype.on;\n\nReadable.prototype.removeListener = function (ev, fn) {\n  var res = Stream.prototype.removeListener.call(this, ev, fn);\n\n  if (ev === 'readable') {\n    // We need to check if there is someone still listening to\n    // readable and reset the state. However this needs to happen\n    // after readable has been emitted but before I/O (nextTick) to\n    // support once('readable', fn) cycles. This means that calling\n    // resume within the same tick will have no\n    // effect.\n    process.nextTick(updateReadableListening, this);\n  }\n\n  return res;\n};\n\nReadable.prototype.removeAllListeners = function (ev) {\n  var res = Stream.prototype.removeAllListeners.apply(this, arguments);\n\n  if (ev === 'readable' || ev === undefined) {\n    // We need to check if there is someone still listening to\n    // readable and reset the state. However this needs to happen\n    // after readable has been emitted but before I/O (nextTick) to\n    // support once('readable', fn) cycles. This means that calling\n    // resume within the same tick will have no\n    // effect.\n    process.nextTick(updateReadableListening, this);\n  }\n\n  return res;\n};\n\nfunction updateReadableListening(self) {\n  var state = self._readableState;\n  state.readableListening = self.listenerCount('readable') > 0;\n\n  if (state.resumeScheduled && !state.paused) {\n    // flowing needs to be set to true now, otherwise\n    // the upcoming resume will not flow.\n    state.flowing = true; // crude way to check if we should resume\n  } else if (self.listenerCount('data') > 0) {\n    self.resume();\n  }\n}\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n} // pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\n\n\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n\n  if (!state.flowing) {\n    debug('resume'); // we flow only if there is no one listening\n    // for readable, but we still have to call\n    // resume()\n\n    state.flowing = !state.readableListening;\n    resume(this, state);\n  }\n\n  state.paused = false;\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    process.nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  debug('resume', state.reading);\n\n  if (!state.reading) {\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n\n  if (this._readableState.flowing !== false) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n\n  this._readableState.paused = true;\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n\n  while (state.flowing && stream.read() !== null) {\n    ;\n  }\n} // wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\n\n\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n\n  var state = this._readableState;\n  var paused = false;\n  stream.on('end', function () {\n    debug('wrapped end');\n\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\n\n    _this.push(null);\n  });\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode\n\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = _this.push(chunk);\n\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  }); // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function methodWrap(method) {\n        return function methodWrapReturnFunction() {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  } // proxy certain important events.\n\n\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  } // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n\n\n  this._read = function (n) {\n    debug('wrapped _read', n);\n\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return this;\n};\n\nif (typeof Symbol === 'function') {\n  Readable.prototype[Symbol.asyncIterator] = function () {\n    if (createReadableStreamAsyncIterator === undefined) {\n      createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');\n    }\n\n    return createReadableStreamAsyncIterator(this);\n  };\n}\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.highWaterMark;\n  }\n});\nObject.defineProperty(Readable.prototype, 'readableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState && this._readableState.buffer;\n  }\n});\nObject.defineProperty(Readable.prototype, 'readableFlowing', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.flowing;\n  },\n  set: function set(state) {\n    if (this._readableState) {\n      this._readableState.flowing = state;\n    }\n  }\n}); // exposed for testing purposes only.\n\nReadable._fromList = fromList;\nObject.defineProperty(Readable.prototype, 'readableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.length;\n  }\n}); // Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\n\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = state.buffer.consume(n, state.decoder);\n  }\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n  debug('endReadable', state.endEmitted);\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    process.nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.\n\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n\n    if (state.autoDestroy) {\n      // In case of duplex streams we need a way to detect\n      // if the writable side is ready for autoDestroy as well\n      var wState = stream._writableState;\n\n      if (!wState || wState.autoDestroy && wState.finished) {\n        stream.destroy();\n      }\n    }\n  }\n}\n\nif (typeof Symbol === 'function') {\n  Readable.from = function (iterable, opts) {\n    if (from === undefined) {\n      from = require('./internal/streams/from');\n    }\n\n    return from(Readable, iterable, opts);\n  };\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n\n  return -1;\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n'use strict';\n\nmodule.exports = Transform;\n\nvar _require$codes = require('../errors').codes,\n    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n    ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,\n    ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;\n\nvar Duplex = require('./_stream_duplex');\n\nrequire('inherits')(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n  var cb = ts.writecb;\n\n  if (cb === null) {\n    return this.emit('error', new ERR_MULTIPLE_CALLBACK());\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n  cb(er);\n  var rs = this._readableState;\n  rs.reading = false;\n\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n  Duplex.call(this, options);\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  }; // start out asking for a readable event once data is transformed.\n\n  this._readableState.needReadable = true; // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  } // When the writable side finishes, then flush out anything remaining.\n\n\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function' && !this._readableState.destroyed) {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n}; // This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\n\n\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n}; // Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\n\n\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && !ts.transforming) {\n    ts.transforming = true;\n\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data); // TODO(BridgeAR): Write a test for these two error cases\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n\n  if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();\n  if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();\n  return stream.push(null);\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n'use strict';\n\nmodule.exports = Writable;\n/* <replacement> */\n\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n} // It seems a linked list but it is not\n// there will be only 2 of these for each stream\n\n\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\n\n\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n/*<replacement>*/\n\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n    getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n    ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n    ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,\n    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,\n    ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,\n    ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,\n    ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;\n\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\n\nrequire('inherits')(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {}; // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream,\n  // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.\n\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n\n  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called\n\n  this.finalCalled = false; // drain event flag.\n\n  this.needDrain = false; // at the start of calling end()\n\n  this.ending = false; // when end() has been called, and returned\n\n  this.ended = false; // when 'finish' is emitted\n\n  this.finished = false; // has it been destroyed\n\n  this.destroyed = false; // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode; // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n\n  this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n\n  this.length = 0; // a flag to see when we're in the middle of a write.\n\n  this.writing = false; // when true all writes will be buffered until .uncork() call\n\n  this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n\n  this.sync = true; // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n\n  this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)\n\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  }; // the callback that the user supplies to write(chunk,encoding,cb)\n\n\n  this.writecb = null; // the amount that is being written when _write is called.\n\n  this.writelen = 0;\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null; // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n\n  this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n\n  this.prefinished = false; // True if the error was already emitted and should not be thrown again\n\n  this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.\n\n  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end')\n\n  this.autoDestroy = !!options.autoDestroy; // count buffered requests\n\n  this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function writableStateBufferGetter() {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})(); // Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\n\n\nvar realHasInstance;\n\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function value(object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function realHasInstance(object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex'); // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the WritableState constructor, at least with V8 6.5\n\n  var isDuplex = this instanceof Duplex;\n  if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);\n  this._writableState = new WritableState(options, this, isDuplex); // legacy.\n\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n    if (typeof options.writev === 'function') this._writev = options.writev;\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n} // Otherwise people can pipe Writable streams, which is just wrong.\n\n\nWritable.prototype.pipe = function () {\n  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb\n\n  errorOrDestroy(stream, er);\n  process.nextTick(cb, er);\n} // Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\n\n\nfunction validChunk(stream, state, chunk, cb) {\n  var er;\n\n  if (chunk === null) {\n    er = new ERR_STREAM_NULL_VALUES();\n  } else if (typeof chunk !== 'string' && !state.objectMode) {\n    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);\n  }\n\n  if (er) {\n    errorOrDestroy(stream, er);\n    process.nextTick(cb, er);\n    return false;\n  }\n\n  return true;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n  if (typeof cb !== 'function') cb = nop;\n  if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  this._writableState.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n    if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState && this._writableState.getBuffer();\n  }\n});\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n\n  return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.highWaterMark;\n  }\n}); // if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\n\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n\n  var len = state.objectMode ? 1 : chunk.length;\n  state.length += len;\n  var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.\n\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    process.nextTick(cb, er); // this can emit finish, and it will always happen\n    // after error\n\n    process.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, er); // this can emit finish, but finish must\n    // always follow error\n\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n  if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();\n  onwriteStateUpdate(state);\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state) || stream.destroyed;\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      process.nextTick(afterWrite, stream, state, finished, cb);\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n} // Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\n\n\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n} // if there's something in the buffer waiting, then process it\n\n\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n    var count = 0;\n    var allBuffers = true;\n\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n\n    buffer.allBuffers = allBuffers;\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks\n\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  } // ignore unnecessary end() calls.\n\n\n  if (!state.ending) endWritable(this, state, cb);\n  return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.length;\n  }\n});\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\n\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n\n    if (err) {\n      errorOrDestroy(stream, err);\n    }\n\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\n\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function' && !state.destroyed) {\n      state.pendingcb++;\n      state.finalCalled = true;\n      process.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n\n  if (need) {\n    prefinish(stream, state);\n\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n\n      if (state.autoDestroy) {\n        // In case of duplex streams we need a way to detect\n        // if the readable side is ready for autoDestroy as well\n        var rState = stream._readableState;\n\n        if (!rState || rState.autoDestroy && rState.endEmitted) {\n          stream.destroy();\n        }\n      }\n    }\n  }\n\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n\n  if (cb) {\n    if (state.finished) process.nextTick(cb);else stream.once('finish', cb);\n  }\n\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  } // reuse the free corkReq.\n\n\n  state.corkedRequestsFree.next = corkReq;\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._writableState === undefined) {\n      return false;\n    }\n\n    return this._writableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._writableState.destroyed = value;\n  }\n});\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\n\nWritable.prototype._destroy = function (err, cb) {\n  cb(err);\n};","'use strict';\n\nvar _Object$setPrototypeO;\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar finished = require('./end-of-stream');\n\nvar kLastResolve = Symbol('lastResolve');\nvar kLastReject = Symbol('lastReject');\nvar kError = Symbol('error');\nvar kEnded = Symbol('ended');\nvar kLastPromise = Symbol('lastPromise');\nvar kHandlePromise = Symbol('handlePromise');\nvar kStream = Symbol('stream');\n\nfunction createIterResult(value, done) {\n  return {\n    value: value,\n    done: done\n  };\n}\n\nfunction readAndResolve(iter) {\n  var resolve = iter[kLastResolve];\n\n  if (resolve !== null) {\n    var data = iter[kStream].read(); // we defer if data is null\n    // we can be expecting either 'end' or\n    // 'error'\n\n    if (data !== null) {\n      iter[kLastPromise] = null;\n      iter[kLastResolve] = null;\n      iter[kLastReject] = null;\n      resolve(createIterResult(data, false));\n    }\n  }\n}\n\nfunction onReadable(iter) {\n  // we wait for the next tick, because it might\n  // emit an error with process.nextTick\n  process.nextTick(readAndResolve, iter);\n}\n\nfunction wrapForNext(lastPromise, iter) {\n  return function (resolve, reject) {\n    lastPromise.then(function () {\n      if (iter[kEnded]) {\n        resolve(createIterResult(undefined, true));\n        return;\n      }\n\n      iter[kHandlePromise](resolve, reject);\n    }, reject);\n  };\n}\n\nvar AsyncIteratorPrototype = Object.getPrototypeOf(function () {});\nvar ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {\n  get stream() {\n    return this[kStream];\n  },\n\n  next: function next() {\n    var _this = this;\n\n    // if we have detected an error in the meanwhile\n    // reject straight away\n    var error = this[kError];\n\n    if (error !== null) {\n      return Promise.reject(error);\n    }\n\n    if (this[kEnded]) {\n      return Promise.resolve(createIterResult(undefined, true));\n    }\n\n    if (this[kStream].destroyed) {\n      // We need to defer via nextTick because if .destroy(err) is\n      // called, the error will be emitted via nextTick, and\n      // we cannot guarantee that there is no error lingering around\n      // waiting to be emitted.\n      return new Promise(function (resolve, reject) {\n        process.nextTick(function () {\n          if (_this[kError]) {\n            reject(_this[kError]);\n          } else {\n            resolve(createIterResult(undefined, true));\n          }\n        });\n      });\n    } // if we have multiple next() calls\n    // we will wait for the previous Promise to finish\n    // this logic is optimized to support for await loops,\n    // where next() is only called once at a time\n\n\n    var lastPromise = this[kLastPromise];\n    var promise;\n\n    if (lastPromise) {\n      promise = new Promise(wrapForNext(lastPromise, this));\n    } else {\n      // fast path needed to support multiple this.push()\n      // without triggering the next() queue\n      var data = this[kStream].read();\n\n      if (data !== null) {\n        return Promise.resolve(createIterResult(data, false));\n      }\n\n      promise = new Promise(this[kHandlePromise]);\n    }\n\n    this[kLastPromise] = promise;\n    return promise;\n  }\n}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {\n  return this;\n}), _defineProperty(_Object$setPrototypeO, \"return\", function _return() {\n  var _this2 = this;\n\n  // destroy(err, cb) is a private API\n  // we can guarantee we have that here, because we control the\n  // Readable class this is attached to\n  return new Promise(function (resolve, reject) {\n    _this2[kStream].destroy(null, function (err) {\n      if (err) {\n        reject(err);\n        return;\n      }\n\n      resolve(createIterResult(undefined, true));\n    });\n  });\n}), _Object$setPrototypeO), AsyncIteratorPrototype);\n\nvar createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {\n  var _Object$create;\n\n  var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {\n    value: stream,\n    writable: true\n  }), _defineProperty(_Object$create, kLastResolve, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kLastReject, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kError, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kEnded, {\n    value: stream._readableState.endEmitted,\n    writable: true\n  }), _defineProperty(_Object$create, kHandlePromise, {\n    value: function value(resolve, reject) {\n      var data = iterator[kStream].read();\n\n      if (data) {\n        iterator[kLastPromise] = null;\n        iterator[kLastResolve] = null;\n        iterator[kLastReject] = null;\n        resolve(createIterResult(data, false));\n      } else {\n        iterator[kLastResolve] = resolve;\n        iterator[kLastReject] = reject;\n      }\n    },\n    writable: true\n  }), _Object$create));\n  iterator[kLastPromise] = null;\n  finished(stream, function (err) {\n    if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {\n      var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise\n      // returned by next() and store the error\n\n      if (reject !== null) {\n        iterator[kLastPromise] = null;\n        iterator[kLastResolve] = null;\n        iterator[kLastReject] = null;\n        reject(err);\n      }\n\n      iterator[kError] = err;\n      return;\n    }\n\n    var resolve = iterator[kLastResolve];\n\n    if (resolve !== null) {\n      iterator[kLastPromise] = null;\n      iterator[kLastResolve] = null;\n      iterator[kLastReject] = null;\n      resolve(createIterResult(undefined, true));\n    }\n\n    iterator[kEnded] = true;\n  });\n  stream.on('readable', onReadable.bind(null, iterator));\n  return iterator;\n};\n\nmodule.exports = createReadableStreamAsyncIterator;","'use strict';\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nvar _require = require('buffer'),\n    Buffer = _require.Buffer;\n\nvar _require2 = require('util'),\n    inspect = _require2.inspect;\n\nvar custom = inspect && inspect.custom || 'inspect';\n\nfunction copyBuffer(src, target, offset) {\n  Buffer.prototype.copy.call(src, target, offset);\n}\n\nmodule.exports =\n/*#__PURE__*/\nfunction () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  _createClass(BufferList, [{\n    key: \"push\",\n    value: function push(v) {\n      var entry = {\n        data: v,\n        next: null\n      };\n      if (this.length > 0) this.tail.next = entry;else this.head = entry;\n      this.tail = entry;\n      ++this.length;\n    }\n  }, {\n    key: \"unshift\",\n    value: function unshift(v) {\n      var entry = {\n        data: v,\n        next: this.head\n      };\n      if (this.length === 0) this.tail = entry;\n      this.head = entry;\n      ++this.length;\n    }\n  }, {\n    key: \"shift\",\n    value: function shift() {\n      if (this.length === 0) return;\n      var ret = this.head.data;\n      if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n      --this.length;\n      return ret;\n    }\n  }, {\n    key: \"clear\",\n    value: function clear() {\n      this.head = this.tail = null;\n      this.length = 0;\n    }\n  }, {\n    key: \"join\",\n    value: function join(s) {\n      if (this.length === 0) return '';\n      var p = this.head;\n      var ret = '' + p.data;\n\n      while (p = p.next) {\n        ret += s + p.data;\n      }\n\n      return ret;\n    }\n  }, {\n    key: \"concat\",\n    value: function concat(n) {\n      if (this.length === 0) return Buffer.alloc(0);\n      var ret = Buffer.allocUnsafe(n >>> 0);\n      var p = this.head;\n      var i = 0;\n\n      while (p) {\n        copyBuffer(p.data, ret, i);\n        i += p.data.length;\n        p = p.next;\n      }\n\n      return ret;\n    } // Consumes a specified amount of bytes or characters from the buffered data.\n\n  }, {\n    key: \"consume\",\n    value: function consume(n, hasStrings) {\n      var ret;\n\n      if (n < this.head.data.length) {\n        // `slice` is the same for buffers and strings.\n        ret = this.head.data.slice(0, n);\n        this.head.data = this.head.data.slice(n);\n      } else if (n === this.head.data.length) {\n        // First chunk is a perfect match.\n        ret = this.shift();\n      } else {\n        // Result spans more than one buffer.\n        ret = hasStrings ? this._getString(n) : this._getBuffer(n);\n      }\n\n      return ret;\n    }\n  }, {\n    key: \"first\",\n    value: function first() {\n      return this.head.data;\n    } // Consumes a specified amount of characters from the buffered data.\n\n  }, {\n    key: \"_getString\",\n    value: function _getString(n) {\n      var p = this.head;\n      var c = 1;\n      var ret = p.data;\n      n -= ret.length;\n\n      while (p = p.next) {\n        var str = p.data;\n        var nb = n > str.length ? str.length : n;\n        if (nb === str.length) ret += str;else ret += str.slice(0, n);\n        n -= nb;\n\n        if (n === 0) {\n          if (nb === str.length) {\n            ++c;\n            if (p.next) this.head = p.next;else this.head = this.tail = null;\n          } else {\n            this.head = p;\n            p.data = str.slice(nb);\n          }\n\n          break;\n        }\n\n        ++c;\n      }\n\n      this.length -= c;\n      return ret;\n    } // Consumes a specified amount of bytes from the buffered data.\n\n  }, {\n    key: \"_getBuffer\",\n    value: function _getBuffer(n) {\n      var ret = Buffer.allocUnsafe(n);\n      var p = this.head;\n      var c = 1;\n      p.data.copy(ret);\n      n -= p.data.length;\n\n      while (p = p.next) {\n        var buf = p.data;\n        var nb = n > buf.length ? buf.length : n;\n        buf.copy(ret, ret.length - n, 0, nb);\n        n -= nb;\n\n        if (n === 0) {\n          if (nb === buf.length) {\n            ++c;\n            if (p.next) this.head = p.next;else this.head = this.tail = null;\n          } else {\n            this.head = p;\n            p.data = buf.slice(nb);\n          }\n\n          break;\n        }\n\n        ++c;\n      }\n\n      this.length -= c;\n      return ret;\n    } // Make sure the linked list only shows the minimal necessary information.\n\n  }, {\n    key: custom,\n    value: function value(_, options) {\n      return inspect(this, _objectSpread({}, options, {\n        // Only inspect one level.\n        depth: 0,\n        // It should not recurse.\n        customInspect: false\n      }));\n    }\n  }]);\n\n  return BufferList;\n}();","'use strict'; // undocumented cb() API, needed for core, not for public API\n\nfunction destroy(err, cb) {\n  var _this = this;\n\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err) {\n      if (!this._writableState) {\n        process.nextTick(emitErrorNT, this, err);\n      } else if (!this._writableState.errorEmitted) {\n        this._writableState.errorEmitted = true;\n        process.nextTick(emitErrorNT, this, err);\n      }\n    }\n\n    return this;\n  } // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  } // if this is a duplex stream mark the writable part as destroyed as well\n\n\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      if (!_this._writableState) {\n        process.nextTick(emitErrorAndCloseNT, _this, err);\n      } else if (!_this._writableState.errorEmitted) {\n        _this._writableState.errorEmitted = true;\n        process.nextTick(emitErrorAndCloseNT, _this, err);\n      } else {\n        process.nextTick(emitCloseNT, _this);\n      }\n    } else if (cb) {\n      process.nextTick(emitCloseNT, _this);\n      cb(err);\n    } else {\n      process.nextTick(emitCloseNT, _this);\n    }\n  });\n\n  return this;\n}\n\nfunction emitErrorAndCloseNT(self, err) {\n  emitErrorNT(self, err);\n  emitCloseNT(self);\n}\n\nfunction emitCloseNT(self) {\n  if (self._writableState && !self._writableState.emitClose) return;\n  if (self._readableState && !self._readableState.emitClose) return;\n  self.emit('close');\n}\n\nfunction undestroy() {\n  if (this._readableState) {\n    this._readableState.destroyed = false;\n    this._readableState.reading = false;\n    this._readableState.ended = false;\n    this._readableState.endEmitted = false;\n  }\n\n  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finalCalled = false;\n    this._writableState.prefinished = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\n\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\n\nfunction errorOrDestroy(stream, err) {\n  // We have tests that rely on errors being emitted\n  // in the same tick, so changing this is semver major.\n  // For now when you opt-in to autoDestroy we allow\n  // the error to be emitted nextTick. In a future\n  // semver major update we should change the default to this.\n  var rState = stream._readableState;\n  var wState = stream._writableState;\n  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);\n}\n\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy,\n  errorOrDestroy: errorOrDestroy\n};","// Ported from https://github.com/mafintosh/end-of-stream with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;\n\nfunction once(callback) {\n  var called = false;\n  return function () {\n    if (called) return;\n    called = true;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    callback.apply(this, args);\n  };\n}\n\nfunction noop() {}\n\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\n\nfunction eos(stream, opts, callback) {\n  if (typeof opts === 'function') return eos(stream, null, opts);\n  if (!opts) opts = {};\n  callback = once(callback || noop);\n  var readable = opts.readable || opts.readable !== false && stream.readable;\n  var writable = opts.writable || opts.writable !== false && stream.writable;\n\n  var onlegacyfinish = function onlegacyfinish() {\n    if (!stream.writable) onfinish();\n  };\n\n  var writableEnded = stream._writableState && stream._writableState.finished;\n\n  var onfinish = function onfinish() {\n    writable = false;\n    writableEnded = true;\n    if (!readable) callback.call(stream);\n  };\n\n  var readableEnded = stream._readableState && stream._readableState.endEmitted;\n\n  var onend = function onend() {\n    readable = false;\n    readableEnded = true;\n    if (!writable) callback.call(stream);\n  };\n\n  var onerror = function onerror(err) {\n    callback.call(stream, err);\n  };\n\n  var onclose = function onclose() {\n    var err;\n\n    if (readable && !readableEnded) {\n      if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n      return callback.call(stream, err);\n    }\n\n    if (writable && !writableEnded) {\n      if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n      return callback.call(stream, err);\n    }\n  };\n\n  var onrequest = function onrequest() {\n    stream.req.on('finish', onfinish);\n  };\n\n  if (isRequest(stream)) {\n    stream.on('complete', onfinish);\n    stream.on('abort', onclose);\n    if (stream.req) onrequest();else stream.on('request', onrequest);\n  } else if (writable && !stream._writableState) {\n    // legacy streams\n    stream.on('end', onlegacyfinish);\n    stream.on('close', onlegacyfinish);\n  }\n\n  stream.on('end', onend);\n  stream.on('finish', onfinish);\n  if (opts.error !== false) stream.on('error', onerror);\n  stream.on('close', onclose);\n  return function () {\n    stream.removeListener('complete', onfinish);\n    stream.removeListener('abort', onclose);\n    stream.removeListener('request', onrequest);\n    if (stream.req) stream.req.removeListener('finish', onfinish);\n    stream.removeListener('end', onlegacyfinish);\n    stream.removeListener('close', onlegacyfinish);\n    stream.removeListener('finish', onfinish);\n    stream.removeListener('end', onend);\n    stream.removeListener('error', onerror);\n    stream.removeListener('close', onclose);\n  };\n}\n\nmodule.exports = eos;","module.exports = function () {\n  throw new Error('Readable.from is not available in the browser')\n};\n","// Ported from https://github.com/mafintosh/pump with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar eos;\n\nfunction once(callback) {\n  var called = false;\n  return function () {\n    if (called) return;\n    called = true;\n    callback.apply(void 0, arguments);\n  };\n}\n\nvar _require$codes = require('../../../errors').codes,\n    ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,\n    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;\n\nfunction noop(err) {\n  // Rethrow the error if it exists to avoid swallowing it\n  if (err) throw err;\n}\n\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\n\nfunction destroyer(stream, reading, writing, callback) {\n  callback = once(callback);\n  var closed = false;\n  stream.on('close', function () {\n    closed = true;\n  });\n  if (eos === undefined) eos = require('./end-of-stream');\n  eos(stream, {\n    readable: reading,\n    writable: writing\n  }, function (err) {\n    if (err) return callback(err);\n    closed = true;\n    callback();\n  });\n  var destroyed = false;\n  return function (err) {\n    if (closed) return;\n    if (destroyed) return;\n    destroyed = true; // request.destroy just do .end - .abort is what we want\n\n    if (isRequest(stream)) return stream.abort();\n    if (typeof stream.destroy === 'function') return stream.destroy();\n    callback(err || new ERR_STREAM_DESTROYED('pipe'));\n  };\n}\n\nfunction call(fn) {\n  fn();\n}\n\nfunction pipe(from, to) {\n  return from.pipe(to);\n}\n\nfunction popCallback(streams) {\n  if (!streams.length) return noop;\n  if (typeof streams[streams.length - 1] !== 'function') return noop;\n  return streams.pop();\n}\n\nfunction pipeline() {\n  for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {\n    streams[_key] = arguments[_key];\n  }\n\n  var callback = popCallback(streams);\n  if (Array.isArray(streams[0])) streams = streams[0];\n\n  if (streams.length < 2) {\n    throw new ERR_MISSING_ARGS('streams');\n  }\n\n  var error;\n  var destroys = streams.map(function (stream, i) {\n    var reading = i < streams.length - 1;\n    var writing = i > 0;\n    return destroyer(stream, reading, writing, function (err) {\n      if (!error) error = err;\n      if (err) destroys.forEach(call);\n      if (reading) return;\n      destroys.forEach(call);\n      callback(error);\n    });\n  });\n  return streams.reduce(pipe);\n}\n\nmodule.exports = pipeline;","'use strict';\n\nvar ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;\n\nfunction highWaterMarkFrom(options, isDuplex, duplexKey) {\n  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;\n}\n\nfunction getHighWaterMark(state, options, duplexKey, isDuplex) {\n  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);\n\n  if (hwm != null) {\n    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {\n      var name = isDuplex ? duplexKey : 'highWaterMark';\n      throw new ERR_INVALID_OPT_VALUE(name, hwm);\n    }\n\n    return Math.floor(hwm);\n  } // Default value\n\n\n  return state.objectMode ? 16 : 16 * 1024;\n}\n\nmodule.exports = {\n  getHighWaterMark: getHighWaterMark\n};","module.exports = require('events').EventEmitter;\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\nexports.finished = require('./lib/internal/streams/end-of-stream.js');\nexports.pipeline = require('./lib/internal/streams/pipeline.js');\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd';\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd';\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd';\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd';\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}","var nextTick = require('process/browser.js').nextTick;\nvar apply = Function.prototype.apply;\nvar slice = Array.prototype.slice;\nvar immediateIds = {};\nvar nextImmediateId = 0;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) { timeout.close(); };\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(window, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// That's not how node.js implements it but the exposed api is the same.\nexports.setImmediate = typeof setImmediate === \"function\" ? setImmediate : function(fn) {\n  var id = nextImmediateId++;\n  var args = arguments.length < 2 ? false : slice.call(arguments, 1);\n\n  immediateIds[id] = true;\n\n  nextTick(function onNextTick() {\n    if (immediateIds[id]) {\n      // fn.call() is faster so we optimize for the common use-case\n      // @see http://jsperf.com/call-apply-segu\n      if (args) {\n        fn.apply(null, args);\n      } else {\n        fn.call(null);\n      }\n      // Prevent ids from leaking\n      exports.clearImmediate(id);\n    }\n  });\n\n  return id;\n};\n\nexports.clearImmediate = typeof clearImmediate === \"function\" ? clearImmediate : function(id) {\n  delete immediateIds[id];\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar punycode = require('punycode');\nvar util = require('./util');\n\nexports.parse = urlParse;\nexports.resolve = urlResolve;\nexports.resolveObject = urlResolveObject;\nexports.format = urlFormat;\n\nexports.Url = Url;\n\nfunction Url() {\n  this.protocol = null;\n  this.slashes = null;\n  this.auth = null;\n  this.host = null;\n  this.port = null;\n  this.hostname = null;\n  this.hash = null;\n  this.search = null;\n  this.query = null;\n  this.pathname = null;\n  this.path = null;\n  this.href = null;\n}\n\n// Reference: RFC 3986, RFC 1808, RFC 2396\n\n// define these here so at least they only have to be\n// compiled once on the first module load.\nvar protocolPattern = /^([a-z0-9.+-]+:)/i,\n    portPattern = /:[0-9]*$/,\n\n    // Special case for a simple path URL\n    simplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/,\n\n    // RFC 2396: characters reserved for delimiting URLs.\n    // We actually just auto-escape these.\n    delims = ['<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t'],\n\n    // RFC 2396: characters not allowed for various reasons.\n    unwise = ['{', '}', '|', '\\\\', '^', '`'].concat(delims),\n\n    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.\n    autoEscape = ['\\''].concat(unwise),\n    // Characters that are never ever allowed in a hostname.\n    // Note that any invalid chars are also handled, but these\n    // are the ones that are *expected* to be seen, so we fast-path\n    // them.\n    nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),\n    hostEndingChars = ['/', '?', '#'],\n    hostnameMaxLen = 255,\n    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,\n    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,\n    // protocols that can allow \"unsafe\" and \"unwise\" chars.\n    unsafeProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\n    // protocols that never have a hostname.\n    hostlessProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\n    // protocols that always contain a // bit.\n    slashedProtocol = {\n      'http': true,\n      'https': true,\n      'ftp': true,\n      'gopher': true,\n      'file': true,\n      'http:': true,\n      'https:': true,\n      'ftp:': true,\n      'gopher:': true,\n      'file:': true\n    },\n    querystring = require('querystring');\n\nfunction urlParse(url, parseQueryString, slashesDenoteHost) {\n  if (url && util.isObject(url) && url instanceof Url) return url;\n\n  var u = new Url;\n  u.parse(url, parseQueryString, slashesDenoteHost);\n  return u;\n}\n\nUrl.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {\n  if (!util.isString(url)) {\n    throw new TypeError(\"Parameter 'url' must be a string, not \" + typeof url);\n  }\n\n  // Copy chrome, IE, opera backslash-handling behavior.\n  // Back slashes before the query string get converted to forward slashes\n  // See: https://code.google.com/p/chromium/issues/detail?id=25916\n  var queryIndex = url.indexOf('?'),\n      splitter =\n          (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',\n      uSplit = url.split(splitter),\n      slashRegex = /\\\\/g;\n  uSplit[0] = uSplit[0].replace(slashRegex, '/');\n  url = uSplit.join(splitter);\n\n  var rest = url;\n\n  // trim before proceeding.\n  // This is to support parse stuff like \"  http://foo.com  \\n\"\n  rest = rest.trim();\n\n  if (!slashesDenoteHost && url.split('#').length === 1) {\n    // Try fast path regexp\n    var simplePath = simplePathPattern.exec(rest);\n    if (simplePath) {\n      this.path = rest;\n      this.href = rest;\n      this.pathname = simplePath[1];\n      if (simplePath[2]) {\n        this.search = simplePath[2];\n        if (parseQueryString) {\n          this.query = querystring.parse(this.search.substr(1));\n        } else {\n          this.query = this.search.substr(1);\n        }\n      } else if (parseQueryString) {\n        this.search = '';\n        this.query = {};\n      }\n      return this;\n    }\n  }\n\n  var proto = protocolPattern.exec(rest);\n  if (proto) {\n    proto = proto[0];\n    var lowerProto = proto.toLowerCase();\n    this.protocol = lowerProto;\n    rest = rest.substr(proto.length);\n  }\n\n  // figure out if it's got a host\n  // user@server is *always* interpreted as a hostname, and url\n  // resolution will treat //foo/bar as host=foo,path=bar because that's\n  // how the browser resolves relative URLs.\n  if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\n    var slashes = rest.substr(0, 2) === '//';\n    if (slashes && !(proto && hostlessProtocol[proto])) {\n      rest = rest.substr(2);\n      this.slashes = true;\n    }\n  }\n\n  if (!hostlessProtocol[proto] &&\n      (slashes || (proto && !slashedProtocol[proto]))) {\n\n    // there's a hostname.\n    // the first instance of /, ?, ;, or # ends the host.\n    //\n    // If there is an @ in the hostname, then non-host chars *are* allowed\n    // to the left of the last @ sign, unless some host-ending character\n    // comes *before* the @-sign.\n    // URLs are obnoxious.\n    //\n    // ex:\n    // http://a@b@c/ => user:a@b host:c\n    // http://a@b?@c => user:a host:c path:/?@c\n\n    // v0.12 TODO(isaacs): This is not quite how Chrome does things.\n    // Review our test case against browsers more comprehensively.\n\n    // find the first instance of any hostEndingChars\n    var hostEnd = -1;\n    for (var i = 0; i < hostEndingChars.length; i++) {\n      var hec = rest.indexOf(hostEndingChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n        hostEnd = hec;\n    }\n\n    // at this point, either we have an explicit point where the\n    // auth portion cannot go past, or the last @ char is the decider.\n    var auth, atSign;\n    if (hostEnd === -1) {\n      // atSign can be anywhere.\n      atSign = rest.lastIndexOf('@');\n    } else {\n      // atSign must be in auth portion.\n      // http://a@b/c@d => host:b auth:a path:/c@d\n      atSign = rest.lastIndexOf('@', hostEnd);\n    }\n\n    // Now we have a portion which is definitely the auth.\n    // Pull that off.\n    if (atSign !== -1) {\n      auth = rest.slice(0, atSign);\n      rest = rest.slice(atSign + 1);\n      this.auth = decodeURIComponent(auth);\n    }\n\n    // the host is the remaining to the left of the first non-host char\n    hostEnd = -1;\n    for (var i = 0; i < nonHostChars.length; i++) {\n      var hec = rest.indexOf(nonHostChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n        hostEnd = hec;\n    }\n    // if we still have not hit it, then the entire thing is a host.\n    if (hostEnd === -1)\n      hostEnd = rest.length;\n\n    this.host = rest.slice(0, hostEnd);\n    rest = rest.slice(hostEnd);\n\n    // pull out port.\n    this.parseHost();\n\n    // we've indicated that there is a hostname,\n    // so even if it's empty, it has to be present.\n    this.hostname = this.hostname || '';\n\n    // if hostname begins with [ and ends with ]\n    // assume that it's an IPv6 address.\n    var ipv6Hostname = this.hostname[0] === '[' &&\n        this.hostname[this.hostname.length - 1] === ']';\n\n    // validate a little.\n    if (!ipv6Hostname) {\n      var hostparts = this.hostname.split(/\\./);\n      for (var i = 0, l = hostparts.length; i < l; i++) {\n        var part = hostparts[i];\n        if (!part) continue;\n        if (!part.match(hostnamePartPattern)) {\n          var newpart = '';\n          for (var j = 0, k = part.length; j < k; j++) {\n            if (part.charCodeAt(j) > 127) {\n              // we replace non-ASCII char with a temporary placeholder\n              // we need this to make sure size of hostname is not\n              // broken by replacing non-ASCII by nothing\n              newpart += 'x';\n            } else {\n              newpart += part[j];\n            }\n          }\n          // we test again with ASCII char only\n          if (!newpart.match(hostnamePartPattern)) {\n            var validParts = hostparts.slice(0, i);\n            var notHost = hostparts.slice(i + 1);\n            var bit = part.match(hostnamePartStart);\n            if (bit) {\n              validParts.push(bit[1]);\n              notHost.unshift(bit[2]);\n            }\n            if (notHost.length) {\n              rest = '/' + notHost.join('.') + rest;\n            }\n            this.hostname = validParts.join('.');\n            break;\n          }\n        }\n      }\n    }\n\n    if (this.hostname.length > hostnameMaxLen) {\n      this.hostname = '';\n    } else {\n      // hostnames are always lower case.\n      this.hostname = this.hostname.toLowerCase();\n    }\n\n    if (!ipv6Hostname) {\n      // IDNA Support: Returns a punycoded representation of \"domain\".\n      // It only converts parts of the domain name that\n      // have non-ASCII characters, i.e. it doesn't matter if\n      // you call it with a domain that already is ASCII-only.\n      this.hostname = punycode.toASCII(this.hostname);\n    }\n\n    var p = this.port ? ':' + this.port : '';\n    var h = this.hostname || '';\n    this.host = h + p;\n    this.href += this.host;\n\n    // strip [ and ] from the hostname\n    // the host field still retains them, though\n    if (ipv6Hostname) {\n      this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n      if (rest[0] !== '/') {\n        rest = '/' + rest;\n      }\n    }\n  }\n\n  // now rest is set to the post-host stuff.\n  // chop off any delim chars.\n  if (!unsafeProtocol[lowerProto]) {\n\n    // First, make 100% sure that any \"autoEscape\" chars get\n    // escaped, even if encodeURIComponent doesn't think they\n    // need to be.\n    for (var i = 0, l = autoEscape.length; i < l; i++) {\n      var ae = autoEscape[i];\n      if (rest.indexOf(ae) === -1)\n        continue;\n      var esc = encodeURIComponent(ae);\n      if (esc === ae) {\n        esc = escape(ae);\n      }\n      rest = rest.split(ae).join(esc);\n    }\n  }\n\n\n  // chop off from the tail first.\n  var hash = rest.indexOf('#');\n  if (hash !== -1) {\n    // got a fragment string.\n    this.hash = rest.substr(hash);\n    rest = rest.slice(0, hash);\n  }\n  var qm = rest.indexOf('?');\n  if (qm !== -1) {\n    this.search = rest.substr(qm);\n    this.query = rest.substr(qm + 1);\n    if (parseQueryString) {\n      this.query = querystring.parse(this.query);\n    }\n    rest = rest.slice(0, qm);\n  } else if (parseQueryString) {\n    // no query string, but parseQueryString still requested\n    this.search = '';\n    this.query = {};\n  }\n  if (rest) this.pathname = rest;\n  if (slashedProtocol[lowerProto] &&\n      this.hostname && !this.pathname) {\n    this.pathname = '/';\n  }\n\n  //to support http.request\n  if (this.pathname || this.search) {\n    var p = this.pathname || '';\n    var s = this.search || '';\n    this.path = p + s;\n  }\n\n  // finally, reconstruct the href based on what has been validated.\n  this.href = this.format();\n  return this;\n};\n\n// format a parsed object into a url string\nfunction urlFormat(obj) {\n  // ensure it's an object, and not a string url.\n  // If it's an obj, this is a no-op.\n  // this way, you can call url_format() on strings\n  // to clean up potentially wonky urls.\n  if (util.isString(obj)) obj = urlParse(obj);\n  if (!(obj instanceof Url)) return Url.prototype.format.call(obj);\n  return obj.format();\n}\n\nUrl.prototype.format = function() {\n  var auth = this.auth || '';\n  if (auth) {\n    auth = encodeURIComponent(auth);\n    auth = auth.replace(/%3A/i, ':');\n    auth += '@';\n  }\n\n  var protocol = this.protocol || '',\n      pathname = this.pathname || '',\n      hash = this.hash || '',\n      host = false,\n      query = '';\n\n  if (this.host) {\n    host = auth + this.host;\n  } else if (this.hostname) {\n    host = auth + (this.hostname.indexOf(':') === -1 ?\n        this.hostname :\n        '[' + this.hostname + ']');\n    if (this.port) {\n      host += ':' + this.port;\n    }\n  }\n\n  if (this.query &&\n      util.isObject(this.query) &&\n      Object.keys(this.query).length) {\n    query = querystring.stringify(this.query);\n  }\n\n  var search = this.search || (query && ('?' + query)) || '';\n\n  if (protocol && protocol.substr(-1) !== ':') protocol += ':';\n\n  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.\n  // unless they had them to begin with.\n  if (this.slashes ||\n      (!protocol || slashedProtocol[protocol]) && host !== false) {\n    host = '//' + (host || '');\n    if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;\n  } else if (!host) {\n    host = '';\n  }\n\n  if (hash && hash.charAt(0) !== '#') hash = '#' + hash;\n  if (search && search.charAt(0) !== '?') search = '?' + search;\n\n  pathname = pathname.replace(/[?#]/g, function(match) {\n    return encodeURIComponent(match);\n  });\n  search = search.replace('#', '%23');\n\n  return protocol + host + pathname + search + hash;\n};\n\nfunction urlResolve(source, relative) {\n  return urlParse(source, false, true).resolve(relative);\n}\n\nUrl.prototype.resolve = function(relative) {\n  return this.resolveObject(urlParse(relative, false, true)).format();\n};\n\nfunction urlResolveObject(source, relative) {\n  if (!source) return relative;\n  return urlParse(source, false, true).resolveObject(relative);\n}\n\nUrl.prototype.resolveObject = function(relative) {\n  if (util.isString(relative)) {\n    var rel = new Url();\n    rel.parse(relative, false, true);\n    relative = rel;\n  }\n\n  var result = new Url();\n  var tkeys = Object.keys(this);\n  for (var tk = 0; tk < tkeys.length; tk++) {\n    var tkey = tkeys[tk];\n    result[tkey] = this[tkey];\n  }\n\n  // hash is always overridden, no matter what.\n  // even href=\"\" will remove it.\n  result.hash = relative.hash;\n\n  // if the relative url is empty, then there's nothing left to do here.\n  if (relative.href === '') {\n    result.href = result.format();\n    return result;\n  }\n\n  // hrefs like //foo/bar always cut to the protocol.\n  if (relative.slashes && !relative.protocol) {\n    // take everything except the protocol from relative\n    var rkeys = Object.keys(relative);\n    for (var rk = 0; rk < rkeys.length; rk++) {\n      var rkey = rkeys[rk];\n      if (rkey !== 'protocol')\n        result[rkey] = relative[rkey];\n    }\n\n    //urlParse appends trailing / to urls like http://www.example.com\n    if (slashedProtocol[result.protocol] &&\n        result.hostname && !result.pathname) {\n      result.path = result.pathname = '/';\n    }\n\n    result.href = result.format();\n    return result;\n  }\n\n  if (relative.protocol && relative.protocol !== result.protocol) {\n    // if it's a known url protocol, then changing\n    // the protocol does weird things\n    // first, if it's not file:, then we MUST have a host,\n    // and if there was a path\n    // to begin with, then we MUST have a path.\n    // if it is file:, then the host is dropped,\n    // because that's known to be hostless.\n    // anything else is assumed to be absolute.\n    if (!slashedProtocol[relative.protocol]) {\n      var keys = Object.keys(relative);\n      for (var v = 0; v < keys.length; v++) {\n        var k = keys[v];\n        result[k] = relative[k];\n      }\n      result.href = result.format();\n      return result;\n    }\n\n    result.protocol = relative.protocol;\n    if (!relative.host && !hostlessProtocol[relative.protocol]) {\n      var relPath = (relative.pathname || '').split('/');\n      while (relPath.length && !(relative.host = relPath.shift()));\n      if (!relative.host) relative.host = '';\n      if (!relative.hostname) relative.hostname = '';\n      if (relPath[0] !== '') relPath.unshift('');\n      if (relPath.length < 2) relPath.unshift('');\n      result.pathname = relPath.join('/');\n    } else {\n      result.pathname = relative.pathname;\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    result.host = relative.host || '';\n    result.auth = relative.auth;\n    result.hostname = relative.hostname || relative.host;\n    result.port = relative.port;\n    // to support http.request\n    if (result.pathname || result.search) {\n      var p = result.pathname || '';\n      var s = result.search || '';\n      result.path = p + s;\n    }\n    result.slashes = result.slashes || relative.slashes;\n    result.href = result.format();\n    return result;\n  }\n\n  var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),\n      isRelAbs = (\n          relative.host ||\n          relative.pathname && relative.pathname.charAt(0) === '/'\n      ),\n      mustEndAbs = (isRelAbs || isSourceAbs ||\n                    (result.host && relative.pathname)),\n      removeAllDots = mustEndAbs,\n      srcPath = result.pathname && result.pathname.split('/') || [],\n      relPath = relative.pathname && relative.pathname.split('/') || [],\n      psychotic = result.protocol && !slashedProtocol[result.protocol];\n\n  // if the url is a non-slashed url, then relative\n  // links like ../.. should be able\n  // to crawl up to the hostname, as well.  This is strange.\n  // result.protocol has already been set by now.\n  // Later on, put the first path part into the host field.\n  if (psychotic) {\n    result.hostname = '';\n    result.port = null;\n    if (result.host) {\n      if (srcPath[0] === '') srcPath[0] = result.host;\n      else srcPath.unshift(result.host);\n    }\n    result.host = '';\n    if (relative.protocol) {\n      relative.hostname = null;\n      relative.port = null;\n      if (relative.host) {\n        if (relPath[0] === '') relPath[0] = relative.host;\n        else relPath.unshift(relative.host);\n      }\n      relative.host = null;\n    }\n    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');\n  }\n\n  if (isRelAbs) {\n    // it's absolute.\n    result.host = (relative.host || relative.host === '') ?\n                  relative.host : result.host;\n    result.hostname = (relative.hostname || relative.hostname === '') ?\n                      relative.hostname : result.hostname;\n    result.search = relative.search;\n    result.query = relative.query;\n    srcPath = relPath;\n    // fall through to the dot-handling below.\n  } else if (relPath.length) {\n    // it's relative\n    // throw away the existing file, and take the new path instead.\n    if (!srcPath) srcPath = [];\n    srcPath.pop();\n    srcPath = srcPath.concat(relPath);\n    result.search = relative.search;\n    result.query = relative.query;\n  } else if (!util.isNullOrUndefined(relative.search)) {\n    // just pull out the search.\n    // like href='?foo'.\n    // Put this after the other two cases because it simplifies the booleans\n    if (psychotic) {\n      result.hostname = result.host = srcPath.shift();\n      //occationaly the auth can get stuck only in host\n      //this especially happens in cases like\n      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n      var authInHost = result.host && result.host.indexOf('@') > 0 ?\n                       result.host.split('@') : false;\n      if (authInHost) {\n        result.auth = authInHost.shift();\n        result.host = result.hostname = authInHost.shift();\n      }\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    //to support http.request\n    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n      result.path = (result.pathname ? result.pathname : '') +\n                    (result.search ? result.search : '');\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  if (!srcPath.length) {\n    // no path at all.  easy.\n    // we've already handled the other stuff above.\n    result.pathname = null;\n    //to support http.request\n    if (result.search) {\n      result.path = '/' + result.search;\n    } else {\n      result.path = null;\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  // if a url ENDs in . or .., then it must get a trailing slash.\n  // however, if it ends in anything else non-slashy,\n  // then it must NOT get a trailing slash.\n  var last = srcPath.slice(-1)[0];\n  var hasTrailingSlash = (\n      (result.host || relative.host || srcPath.length > 1) &&\n      (last === '.' || last === '..') || last === '');\n\n  // strip single dots, resolve double dots to parent dir\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = srcPath.length; i >= 0; i--) {\n    last = srcPath[i];\n    if (last === '.') {\n      srcPath.splice(i, 1);\n    } else if (last === '..') {\n      srcPath.splice(i, 1);\n      up++;\n    } else if (up) {\n      srcPath.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (!mustEndAbs && !removeAllDots) {\n    for (; up--; up) {\n      srcPath.unshift('..');\n    }\n  }\n\n  if (mustEndAbs && srcPath[0] !== '' &&\n      (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {\n    srcPath.unshift('');\n  }\n\n  if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {\n    srcPath.push('');\n  }\n\n  var isAbsolute = srcPath[0] === '' ||\n      (srcPath[0] && srcPath[0].charAt(0) === '/');\n\n  // put the host back\n  if (psychotic) {\n    result.hostname = result.host = isAbsolute ? '' :\n                                    srcPath.length ? srcPath.shift() : '';\n    //occationaly the auth can get stuck only in host\n    //this especially happens in cases like\n    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n    var authInHost = result.host && result.host.indexOf('@') > 0 ?\n                     result.host.split('@') : false;\n    if (authInHost) {\n      result.auth = authInHost.shift();\n      result.host = result.hostname = authInHost.shift();\n    }\n  }\n\n  mustEndAbs = mustEndAbs || (result.host && srcPath.length);\n\n  if (mustEndAbs && !isAbsolute) {\n    srcPath.unshift('');\n  }\n\n  if (!srcPath.length) {\n    result.pathname = null;\n    result.path = null;\n  } else {\n    result.pathname = srcPath.join('/');\n  }\n\n  //to support request.http\n  if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n    result.path = (result.pathname ? result.pathname : '') +\n                  (result.search ? result.search : '');\n  }\n  result.auth = relative.auth || result.auth;\n  result.slashes = result.slashes || relative.slashes;\n  result.href = result.format();\n  return result;\n};\n\nUrl.prototype.parseHost = function() {\n  var host = this.host;\n  var port = portPattern.exec(host);\n  if (port) {\n    port = port[0];\n    if (port !== ':') {\n      this.port = port.substr(1);\n    }\n    host = host.substr(0, host.length - port.length);\n  }\n  if (host) this.hostname = host;\n};\n","'use strict';\n\nmodule.exports = {\n  isString: function(arg) {\n    return typeof(arg) === 'string';\n  },\n  isObject: function(arg) {\n    return typeof(arg) === 'object' && arg !== null;\n  },\n  isNull: function(arg) {\n    return arg === null;\n  },\n  isNullOrUndefined: function(arg) {\n    return arg == null;\n  }\n};\n","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n  if (config('noDeprecation')) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (config('throwDeprecation')) {\n        throw new Error(msg);\n      } else if (config('traceDeprecation')) {\n        console.trace(msg);\n      } else {\n        console.warn(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n  // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n  try {\n    if (!global.localStorage) return false;\n  } catch (_) {\n    return false;\n  }\n  var val = global.localStorage[name];\n  if (null == val) return false;\n  return String(val).toLowerCase() === 'true';\n}\n","module.exports = extend\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n    var target = {}\n\n    for (var i = 0; i < arguments.length; i++) {\n        var source = arguments[i]\n\n        for (var key in source) {\n            if (hasOwnProperty.call(source, key)) {\n                target[key] = source[key]\n            }\n        }\n    }\n\n    return target\n}\n"]}