function _regeneratorRuntime() {
    _regeneratorRuntime = function () {
        return t;
    };
    var t = { name: "_regenerator" },
        e = Object.prototype, a = e.hasOwnProperty, n = "function" == typeof Symbol ? Symbol : {}, i = n.iterator || "@@iterator", s = n.asyncIterator || "@@asyncIterator", r = n.toStringTag || "@@toStringTag";
    function o(t, e, a) {
        return Object.defineProperty(t, e, {
            value: a,
            enumerable: !0,
            configurable: !0,
            writable: !0
        }), t[e];
    }
    try {
        o({}, "");
    } catch (t) {
        o = function (t, e, a) {
            return t[e] = a;
        };
    }
    function c(t, e, a, n) {
        var i = e && e.prototype instanceof h ? e : h, s = Object.create(i.prototype), r = new L(n || []);
        return s._invoke = function (t, e, a) {
            var n = "suspendedStart";
            return function (i, s) {
                if ("executing" === n) throw new Error("Generator is already running");
                if ("completed" === n) {
                    if ("throw" === i) throw s;
                    return T();
                }
                for (a.method = i, a.arg = s; ;) {
                    var r = a.delegate;
                    if (r) {
                        var o = k(r, a);
                        if (o) {
                            if (o === u) continue;
                            return o;
                        }
                    }
                    if ("next" === a.method) a.sent = a._sent = a.arg; else if ("throw" === a.method) {
                        if ("suspendedStart" === n) throw n = "completed", a.arg;
                        a.dispatchException(a.arg);
                    } else "return" === a.method && a.abrupt("return", a.arg);
                    n = "executing";
                    var c = l(t, e, a);
                    if ("normal" === c.type) {
                        if (n = a.done ? "completed" : "suspendedYield", c.arg === u) continue;
                        return {
                            value: c.arg,
                            done: a.done
                        };
                    }
                    "throw" === c.type && (n = "completed", a.method = "throw", a.arg = c.arg);
                }
            };
        }(t, a, r), s;
    }
    function l(t, e, a) {
        try {
            return {
                type: "normal",
                arg: t.call(e, a)
            };
        } catch (t) {
            return {
                type: "throw",
                arg: t
            };
        }
    }
    t.wrap = c;
    var u = {};
    function h() { }
    function d() { }
    function f() { }
    var _ = {};
    o(_, i, function () {
        return this;
    });
    var m = Object.getPrototypeOf, g = m && m(m(S([])));
    g && g !== e && a.call(g, i) && (_ = g);
    var p = f.prototype = h.prototype = Object.create(_);
    function v(t) {
        ["next", "throw", "return"].forEach(function (e) {
            o(t, e, function (t) {
                return this._invoke(e, t);
            });
        });
    }
    function y(t, e) {
        var n;
        this._invoke = function (i, s) {
            function r() {
                return new e(function (n, r) {
                    !function n(i, s, r, o) {
                        var c = l(t[i], t, s);
                        if ("throw" !== c.type) {
                            var u = c.arg, h = u.value;
                            return h && "object" == _typeof(h) && a.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
                                n("next", t, r, o);
                            }, function (t) {
                                n("throw", t, r, o);
                            }) : e.resolve(h).then(function (t) {
                                u.value = t, r(u);
                            }, function (t) {
                                return n("throw", t, r, o);
                            });
                        }
                        o(c.arg);
                    }(i, s, n, r);
                });
            }
            return n = n ? n.then(r, r) : r();
        };
    }
    function k(t, e) {
        var a = t.iterator[e.method];
        if (void 0 === a) {
            if (e.delegate = null, "throw" === e.method) {
                if (t.iterator.return && (e.method = "return", e.arg = void 0, k(t, e), "throw" === e.method)) return u;
                e.method = "throw", e.arg = new TypeError("The iterator does not provide a 'throw' method");
            }
            return u;
        }
        var n = l(a, t.iterator, e.arg);
        if ("throw" === n.type) return e.method = "throw", e.arg = n.arg, e.delegate = null,
            u;
        var i = n.arg;
        return i ? i.done ? (e[t.resultName] = i.value, e.next = t.nextLoc, "return" !== e.method && (e.method = "next",
            e.arg = void 0), e.delegate = null, u) : i : (e.method = "throw", e.arg = new TypeError("iterator result is not an object"),
                e.delegate = null, u);
    }
    function C(t) {
        var e = {
            tryLoc: t[0]
        };
        1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]),
            this.tryEntries.push(e);
    }
    function I(t) {
        var e = t.completion || {};
        e.type = "normal", delete e.arg, t.completion = e;
    }
    function L(t) {
        this.tryEntries = [{
            tryLoc: "root"
        }], t.forEach(C, this), this.reset(!0);
    }
    function S(t) {
        if (t) {
            var e = t[i];
            if (e) return e.call(t);
            if ("function" == typeof t.next) return t;
            if (!isNaN(t.length)) {
                var n = -1, s = function e() {
                    for (; ++n < t.length;) if (a.call(t, n)) return e.value = t[n], e.done = !1, e;
                    return e.value = void 0, e.done = !0, e;
                };
                return s.next = s;
            }
        }
        return {
            next: T
        };
    }
    function T() {
        return {
            value: void 0,
            done: !0
        };
    }
    return d.prototype = f, o(p, "constructor", f), o(f, "constructor", d), d.displayName = o(f, r, "GeneratorFunction"),
        t.isGeneratorFunction = function (t) {
            var e = "function" == typeof t && t.constructor;
            return !!e && (e === d || "GeneratorFunction" === (e.displayName || e.name));
        }, t.mark = function (t) {
            return Object.setPrototypeOf ? Object.setPrototypeOf(t, f) : (t.__proto__ = f, o(t, r, "GeneratorFunction")),
                t.prototype = Object.create(p), t;
        }, t.awrap = function (t) {
            return {
                __await: t
            };
        }, v(y.prototype), o(y.prototype, s, function () {
            return this;
        }), t.AsyncIterator = y, t.async = function (e, a, n, i, s) {
            void 0 === s && (s = Promise);
            var r = new y(c(e, a, n, i), s);
            return t.isGeneratorFunction(a) ? r : r.next().then(function (t) {
                return t.done ? t.value : r.next();
            });
        }, v(p), o(p, r, "Generator"), o(p, i, function () {
            return this;
        }), o(p, "toString", function () {
            return "[object Generator]";
        }), t.keys = function (t) {
            var e = [];
            for (var a in t) e.push(a);
            return e.reverse(), function a() {
                for (; e.length;) {
                    var n = e.pop();
                    if (n in t) return a.value = n, a.done = !1, a;
                }
                return a.done = !0, a;
            };
        }, t.values = S, L.prototype = {
            constructor: L,
            reset: function (t) {
                if (this.prev = 0, this.next = 0, this.sent = this._sent = void 0, this.done = !1,
                    this.delegate = null, this.method = "next", this.arg = void 0, this.tryEntries.forEach(I),
                    !t) for (var e in this) "t" === e.charAt(0) && a.call(this, e) && !isNaN(+e.slice(1)) && (this[e] = void 0);
            },
            stop: function () {
                this.done = !0;
                var t = this.tryEntries[0].completion;
                if ("throw" === t.type) throw t.arg;
                return this.rval;
            },
            dispatchException: function (t) {
                if (this.done) throw t;
                var e = this;
                function n(a, n) {
                    return r.type = "throw", r.arg = t, e.next = a, n && (e.method = "next", e.arg = void 0),
                        !!n;
                }
                for (var i = this.tryEntries.length - 1; i >= 0; --i) {
                    var s = this.tryEntries[i], r = s.completion;
                    if ("root" === s.tryLoc) return n("end");
                    if (s.tryLoc <= this.prev) {
                        var o = a.call(s, "catchLoc"), c = a.call(s, "finallyLoc");
                        if (o && c) {
                            if (this.prev < s.catchLoc) return n(s.catchLoc, !0);
                            if (this.prev < s.finallyLoc) return n(s.finallyLoc);
                        } else if (o) {
                            if (this.prev < s.catchLoc) return n(s.catchLoc, !0);
                        } else {
                            if (!c) throw new Error("try statement without catch or finally");
                            if (this.prev < s.finallyLoc) return n(s.finallyLoc);
                        }
                    }
                }
            },
            abrupt: function (t, e) {
                for (var n = this.tryEntries.length - 1; n >= 0; --n) {
                    var i = this.tryEntries[n];
                    if (i.tryLoc <= this.prev && a.call(i, "finallyLoc") && this.prev < i.finallyLoc) {
                        var s = i;
                        break;
                    }
                }
                s && ("break" === t || "continue" === t) && s.tryLoc <= e && e <= s.finallyLoc && (s = null);
                var r = s ? s.completion : {};
                return r.type = t, r.arg = e, s ? (this.method = "next", this.next = s.finallyLoc,
                    u) : this.complete(r);
            },
            complete: function (t, e) {
                if ("throw" === t.type) throw t.arg;
                return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg,
                    this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e),
                    u;
            },
            finish: function (t) {
                for (var e = this.tryEntries.length - 1; e >= 0; --e) {
                    var a = this.tryEntries[e];
                    if (a.finallyLoc === t) return this.complete(a.completion, a.afterLoc), I(a), u;
                }
            },
            catch: function (t) {
                for (var e = this.tryEntries.length - 1; e >= 0; --e) {
                    var a = this.tryEntries[e];
                    if (a.tryLoc === t) {
                        var n = a.completion;
                        if ("throw" === n.type) {
                            var i = n.arg;
                            I(a);
                        }
                        return i;
                    }
                }
                throw new Error("illegal catch attempt");
            },
            delegateYield: function (t, e, a) {
                return this.delegate = {
                    iterator: S(t),
                    resultName: e,
                    nextLoc: a
                }, "next" === this.method && (this.arg = void 0), u;
            }
        }, t;
}
gmodule.exports = _regeneratorRuntime();