//mini2 by dandavis [CCBY2]

F = function Fn() {
    return {
        I: function(e) {
            return Math.floor(e)
        },
        method: function(e, t, n) {
            return e[this[0]].apply(e, this.slice(1))
        },
        generic: function(e, n, r) {
            return t = this,
            e = t[0](e),
            e[t[1]].apply(e, t.slice(2))
        },
        If: function(e) {
            return Function("a,b", "return  " + e + "?a:undefined")
        },
        K: function(e) {
            return e
        },
        argument: function() {
            return arguments[this]
        },
        as: function(e) {
            return function(e, t, n) {
                return fn.call(this.call ? this.call(n, e) : this, e, t, n)
            }
        },
        avg: function(e, b, c) {
            return this[0] += e / c.length
        },
        b: function(e, t) {
            return t
        },
        byConstructors: function(e) {
            return e.constructor == this
        },
        byTypes: function(e) {
            return typeof e == this ? 1 : 0
        },
        c: function(e, t, n) {
            return n
        },
        capture: function(e) {
            return [].slice.call(arguments)
        },
        contains: function(e) {
            return e.indexOf(this) > -1
        },
        count: function(e) {
            return this[e] = this[e] ? this[e] + 1 : 1
        },
        defined: function(e) {
            return !{
                "null": 1,
                "undefined": 1
            }[typeof e]
        },
        different: function(e) {
            return e != this
        },
        equal: function(e) {
            return e === this
        },
        even: function(e) {
            return e % 2 === 0
        },
        extract: function(e) {
            return e[this]
        },
        extractList: function(e) {
            return this.map(function(t) {
                return e[t]
            })
        },
        extractMany: function(e) {
            return obMap(this).map(function(t) {
                return (t[1] && t[1].call && t[1] || String)(e[t[0]])
            })
        },
        f: function(e) {
            return Function("a", "b", "c", ";return " + e)
        },
        fill: function(e) {
            return this.call ? this.apply(c, arguments) : this
        },
        getSlot: function(e, t) {
            return t
        },
        gt: function(e) {
            return e > this
        },
        gte: function(e) {
            return e >= this
        },
        guard: function(e, t) {
            return function(n) {
                return e.call(this, [].slice.call(arguments, 0, t || 99))
            }
        },
        has: function(e) {
            return e[this] !== undefined
        },
        invoke: function(e) {
            return e[this]()
        },
        isOwn: function(e, k) {
            return hasOwnProperty.call(e, k)
        },
        isInt: function(e) {
            return Math.floor(e, 10) === e
        },
        isNeg: function(e) {
            return e < 0
        },
        isPos: function(e) {
            return e >= 0
        },
        isElement: function(e) {
            return e instanceof Element
        },
        isArray: function(e) {
            return Array.isArray(e)
        },
        isBoolean: function(e) {
            return typeof e == "boolean"
        },
        isObject: function(e) {
            return Object(e) === e
        },
        isRegExp: function(e) {
            return e && e.constructor === RegExp
        },
        isNull: function(e) {
            return e === null
        },
        isUndefined: function(e) {
            var u;
            return e === u
        },
        isDefined: function(e) {
            return e != null
        },
        isNumber: function(e) {
            return +e || e === 0
        },
        isEmpty: function(e) {
            if (!e)
                return !0;
            for (var i in e)
                if (F.isOwn(e, i))
                    return !1;
            return !0
        },
        isDate: function(e) {
            return e && e.constructor === Date
        },
        k: function(e) {
            return e
        },
        keys: function(e) {
            return Object.keys(e)
        },
        lt: function(e) {
            return e < this
        },
        lte: function(e) {
            return e <= this
        },
        match: function(e) {
            return String(e).indexOf(this) !== -1
        },
        max: function(e, t) {
            return Math.max(e, t)
        },
        min: function(e, t) {
            return Math.min(e, t)
        },
        negate: function(e) {
            return function() {
                return !e.apply(this, arguments)
            }
        },
        not: function(e) {
            return e != this
        },
        obKeys: function(e) {
            var t = []
              , n = 0;
            for (var r in e)
                e.hasOwnProperty(r) && (t[n++] = r);
            return t
        },
        obKeysx: function(e) {
            var t = []
              , n = 0;
            for (var r in e)
                t[n++] = r;
            return t
        },
        obMap: function(e) {
            var t = []
              , n = 0;
            for (var r in e)
                e.hasOwnProperty(r) && (t[n++] = [r, e[r]]);
            return t
        },
        obMapx: function(e) {
            var t = []
              , n = 0;
            for (var r in e)
                t[n++] = [r, e[r]];
            return t
        },
        obVals: function(e) {
            var t = []
              , n = 0;
            for (var r in e)
                e.hasOwnProperty(r) && (t[n++] = e[r]);
            return t
        },
        obValsx: function(e) {
            var t = []
              , n = 0;
            for (var r in e)
                t[n++] = e[r];
            return t
        },
        odd: function(e) {
            return e % 2 !== 0
        },
        ok: function(e) {
            return e != null
        },
        percent: function(e) {
            return e / this
        },
        isDate: function(e) {
            return e && e.constructor === Date
        },
        run: function(e) {
            return this(e)
        },
        same: function(e) {
            return e == this
        },
        shuffle: function _(a, b, c) {
            var out = b ? _.r : _.r = c.slice()
              , ol = out.length;
            return ol === 1 && delete _.r,
            out.splice(Math.floor(Math.random() * ol), 1)[0]
        },
        slice: function(e) {
            return [].slice.call(e, +this || 0)
        },
        sum: function(e, t) {
            return e + t
        },
        tag: function(e) {
            return "<" + this + ">" + e + "</" + this + ">"
        },
        this2a: function(e) {
            return this.apply(e)
        },
        times: function(e) {
            return e * this
        },
        typeOf: function(e) {
            return typeof e
        },
        unequal: function(e) {
            return e !== this
        },
        unique: function(e, t, n) {
            return n.lastIndexOf(e) == t
        },
        zip: function(e, t) {
            return [e, this[t]]
        }
    }
}(),
F.pluck = F.extract,
F.S = String,
F.N = Number,
F.B = Boolean,
F.R = RegExp,
F.O = Object,
F.bind = Function.prototype.call.bind(Function.prototype),
F.slice = Function.prototype.call.bind(Array.prototype.slice);

JSON.view = function(a) {
    return JSON.stringify(a, null, "\t")
}
;
document.head = document.head || Q("head")[0];
obKeys = Object.keys;
obValsl = eval.call.bind([].slice);
el = document.getElementById.bind(document);
function els(a) {
    return el(a).style
}
function obVals(a) {
    var c = [], b, e = eval.call.bind(hasOwnProperty, a);
    for (b in a)
        e(b) && (c[c.length] = a[b]);
    return c
}
function obMap(a, c) {
    var b = [], e, d, f = eval.call.bind(hasOwnProperty, a);
    for (d in a)
        if (c || f(d))
            e = b[b.length] = [],
            e.k = e.key = e[0] = d,
            e.v = e.value = e[1] = a[d];
    return b
}
function aCSS(a) {
    document.head.appendChild(document.createElement("style")).innerHTML = a
}
function jsGet(a) {
    var c = document
      , c = c.head.appendChild(c.createElement("script"));
    c.src = a;
    return c
}
function F$(a) {
    return Function("a,b,c", a)
}
function ping(a) {
    (new Image).src = a
}
function defer(a, c) {
    return setTimeout(a, c || 50)
}
function IO(a, c) {
    var b = new XMLHttpRequest;
    b.open(c ? "POST" : "GET", a, !1);
    b.send(c);
    return b.responseText
}
function dataURL(a, c) {
    return "data:" + (c || "text/html") + ("undefined" !== typeof btoa ? ";base64," : ",") + (this.btoa || this.encodeURIComponent)(a)
}
(function() {
    var a = Array.prototype;
    a.random = function() {
        return this[Math.floor(Math.random() * (this.length - 1 + 1))]
    }
    ;
    a._ = function(b, e) {
        var a = typeof b;
        return "string" === a ? "." === b[0] ? this.map(Function("a", "return a" + b), e).filter(Boolean) : this.map(F.extract, b).filter(Boolean) : "function" === a ? this.map(b, e) : b.toFixed && "number" === a ? this.map(F.extract, b).filter(Boolean) : !1
    }
    ;
    a.unique = function() {
        for (var b = [], e = this.length, a = 0; a < e; a++)
            -1 == b.indexOf(this[a]) && (b[b.length] = this[a]);
        return b
    }
    ;
    var c = Math;
    c.sum = function() {
        return [].slice.call(arguments).reduce(F.sum)
    }
    ;
    c.avg = function() {
        return c.sum.apply(0, arguments) / arguments.length
    }
    ;
    c.sign = Math.sign || function(b) {
        return 0 < b && 1 | 0 > b && -1 || 0
    }
}
)();
var dom = function() {
    function a(b) {
        return c[b]
    }
    var c = {
        "&": "&amp",
        "'": "&quot;",
        "<": "&lt;",
        ">": "&gt;"
    };
    return {
        div: function(b, a) {
            var d = document.createElement(b || "div");
            d.add = function(b, a, e) {
                d.appendChild(b.charAt ? dom.create(b, a, e) : b);
                return d
            }
            ;
            if (a) {
                if (a.nodeName)
                    return d.appendChild(a),
                    d;
                a.split && (d[{
                    br: "title",
                    textarea: "value",
                    input: "value",
                    option: "text",
                    style: "text",
                    script: "text",
                    img: "src"
                }[b] || "innerHTML"] = a)
            }
            return d
        },
        attribs: function(b, a) {
            b.charAt && (b = document.createElement(b));
            var d = {
                htmlFor: "for",
                className: "class"
            }, c;
            for (c in a)
                if (a.hasOwnProperty(c)) {
                    var g = d[c] || c;
                    "style" == c && (b.style.cssText = a[c]);
                    try {
                        b[c] = a[c]
                    } catch (h) {
                        b.setAttribute(g, a[c])
                    }
                }
            return b
        },
        create: function(b, a, d) {
            b = dom.div(b, a);
            d && dom.attribs(b, d);
            return b
        },
        prependChild: function(b, a) {
            return a.insertBefore(b, a.firstChild)
        },
        text: function(b) {
            return b.value || b.textContent || b.innerText || b.innerHTML || b.nodeValue
        },
        encodeHTML: function(b) {
            return b.replace(/[&'<>]/g, a)
        },
        kill: function(b) {
            b.parentNode.removeChild(b);
            return b
        },
        getParent2: function(b) {
            return b.parentNode
        },
        getParent: function(b, a) {
            if (!a)
                return b.parentNode;
            for (; (b = b.parentNode) && b.nodeName.toLowerCase() != a; )
                ;
            return b
        },
        replace: function(b, a) {
            a.parentNode.replaceChild(b, a)
        },
        addStyle: function(b, a) {
            var d = document.styleSheets;
            d && d[0] || document.head.appendChild(dom.create("style", "", {
                type: "text/css"
            }));
            d = d[0];
            return d.insertRule ? d.insertRule(b + " { " + a + " } ", 0) : d.addRule(b, a)
        }
    }
}();
function Q(a, c) {
    c = c || document.documentElement;
    c.split && (c = Q(c)[0]);
    return obValsl(c.querySelectorAll(a)) || []
}
function addEvent(a, c, b) {
    return (b && a || self).addEventListener(b && c || a, b || c, !1)
}
function aGet(a, c, b) {
    var e = new XMLHttpRequest;
    e.onreadystatechange = function() {
        4 == e.readyState && 200 == e.status && c(e.responseText, e)
    }
    ;
    e.open(b ? "POST" : "GET", a, !0);
    e.send(void 0 !== b ? b : "");
    return e
}
function download(a, c, b) {
    var e = document
      , d = e.createElement("a");
    b = b || "application/octet-stream";
    if (window.MSBlobBuilder)
        return b = new MSBlobBuilder,
        b.append(a),
        navigator.msSaveBlob(b, c);
    if ("download"in d)
        return d.href = "data:" + b + "," + escape(a),
        d.setAttribute("download", c),
        d.innerHTML = "downloading...",
        e.body.appendChild(d),
        setTimeout(function() {
            d.click();
            e.body.removeChild(d)
        }, 66),
        !0;
    var f = e.createElement("iframe");
    e.body.appendChild(f);
    f.src = "data:" + b + "," + escape(a);
    setTimeout(function() {
        e.body.removeChild(f)
    }, 333);
    return !0
}
function required(a) {
    var c = [].join.call(arguments, ",");
    jsGet("http://danml.com/js/?" + c.concat(",complete"));
    return function(b) {
        _requiredCB = function() {
            b(a)
        }
    }
}
/*
(function(a) {
    function c() {
        this[b] = [];
        this[e] = []
    }
    var b = "keys"
      , e = "values";
    c.prototype = {
        get: function(a, c) {
            return a = this[b].indexOf(a),
            -1 == a ? c : this[e][a]
        },
        set: function(a, c) {
            var g = this[b].indexOf(a);
            -1 == g && (g = this[b].length);
            this[b][g] = a;
            this[e][g] = c
        },
        has: function(a) {
            return -1 !== this[b].indexOf(a)
        },
        "delete": function(a) {
            a = this[b].indexOf(a);
            if (-1 !== a)
                return this[b][a] = this[e][a] = void 0,
                !0
        },
        clear: function() {
            this[b].length = this[e].length = 0
        }
    };
    self[a] = self[a] || c
}
)("WeakMap");
function Set() {
    var a = []
      , c = Object.create && Object.create(null) || {}
      , b = Object.defineProperty.bind(Object, c);
    b("delete", {
        value: function(b) {
            -1 !== (b = a.indexOf(b)) && a.splice(b, 1);
            return !0
        }
    });
    b("add", {
        value: function(b) {
            -1 === a.indexOf(b) && a.push(b)
        }
    });
    b("has", {
        value: function(b) {
            return -1 !== a.indexOf(b)
        }
    });
    b("size", {
        get: function() {
            return a.length
        }
    });
    return c
}
(function() {
    var a = String.prototype
      , c = ["!==-1", "===0", "+s.length===this.length"];
    ["contains", "startsWith", "endsWith"].forEach(function(b, e) {
        a[b] = a[b] || Function("s", "return this.indexOf(s)" + c[e])
    });
    a.toArray = a.toArray || function() {
        return this.split("")
    }
    ;
    a.repeat = a.repeat || function(b) {
        return Array(b + 1).join(this)
    }
}
)();
(function(a) {
    a.isNaN = a.isNaN || isNaN;
    a.toInteger = a.toInteger || Math.floor;
    a.isFinite = a.isFinite || isFinite;
    a.isInteger = a.isInteger || function(a) {
        return ~~a === a
    }
}
)(Number);



(function(a) {
    function c(b, c) {
        for (var d in c)
            c[a](d) && (b[d] = c[d]);
        return b
    }
    c(Object, {
        merge: c,
        update: function(b, c) {
            for (var d in c)
                c[a](d) && !b[a](d) && (b[d] = c[d]);
            return b
        },
        common: function(b, c, d) {
            d = d || {};
            for (var f in c)
                c[a](f) && b[a](f) && (d[f] = c[f]);
            return d
        },
        mutual: function(b, c, d) {
            d = d || {};
            for (var f in c)
                c[a](f) && b[a](f) && b[v] === c[f] && (d[f] = c[f]);
            return d
        },
        without: function(b, c, d) {
            d = d || {};
            for (var f in c)
                b[a](f) && !c[a](f) && (d[f] = c[f]);
            return d
        },
        is: function(a, c) {
            return isNaN(a) && isNaN(c) ? !0 : a === c
        },
        isnt: function(a, c) {
            return !Object.is(a, c)
        }
    })
}
)("hasOwnProperty");

*/
function Enum(a) {
    var c = {};
    if (!a)
        throw "enum: not enough arguments";
    a && !a.map && (a = [a]);
    1 < arguments.length && (a = [].slice.call(arguments));
    a.map(function(a, e) {
        Object.defineProperty(c, a, {
            value: e
        })
    });
    return c
}
window.mini && window.mini();