text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">

    <head>
        <meta content="text/html; charset=UTF-8" http-equiv="Content-Type" />
        <title>Iris - An Instagram Client For iPad</title>
        <link href="css/style.css" type="text/css" rel="stylesheet" />
        <script type="text/javascript">
            (function (window, undefined) {
                var document = window.document,
                    navigator = window.navigator,
                    location = window.location;
                var jQuery = (function () {
                    var jQuery = function (selector, context) {
                        return new jQuery.fn.init(selector, context, rootjQuery);
                    }, _jQuery = window.jQuery,
                        _$ = window.$,
                        rootjQuery, quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
                        rnotwhite = /\S/,
                        trimLeft = /^\s+/,
                        trimRight = /\s+$/,
                        rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
                        rvalidchars = /^[\],:{}\s]*$/,
                        rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
                        rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
                        rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
                        rwebkit = /(webkit)[ \/]([\w.]+)/,
                        ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
                        rmsie = /(msie) ([\w.]+)/,
                        rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
                        rdashAlpha = /-([a-z]|[0-9])/gi,
                        rmsPrefix = /^-ms-/,
                        fcamelCase = function (all, letter) {}, userAgent = navigator.userAgent,
                        browserMatch, readyList, DOMContentLoaded, toString = Object.prototype.toString,
                        hasOwn = Object.prototype.hasOwnProperty,
                        push = Array.prototype.push,
                        slice = Array.prototype.slice,
                        trim = String.prototype.trim,
                        indexOf = Array.prototype.indexOf,
                        class2type = {};
                    jQuery.fn = jQuery.prototype = {
                        constructor: jQuery,
                        init: function (selector, context, rootjQuery) {
                            var match, elem, ret, doc;
                            if (!selector) {
                                return this;
                            }

                            if (selector.nodeType) {
                                this.context = this[0] = selector;
                                this.length = 1;
                                return this;
                            }

                            if (selector === 'body');

                            if (typeof selector === 'string') {
                                if (selector.charAt(0) === '<' && selector.charAt(selector.length - 1) === '>' && selector.length >= 3) {
                                    match = [null, selector, null];
                                } else {
                                    match = quickExpr.exec(selector);
                                }

                                if (match && (match[1] || !context)) {
                                    if (match[1]) {
                                        context = context instanceof jQuery ? 0 : context;
                                        doc = context ? context.ownerDocument || context : document;
                                        ret = rsingleTag.exec(selector);
                                        if (ret);
                                        else {
                                            ret = jQuery.buildFragment([match[1]], [doc]);
                                            selector = (ret.cacheable ? jQuery.clone(ret.fragment) : 0).childNodes;
                                        }

                                        return jQuery.merge(this, selector);
                                    } else {
                                        elem = document.getElementById(match[2]);
                                        if (elem && elem.parentNode) {
                                            if (elem.id !== match[2]);

                                            this.length = 1;
                                            this[0] = elem;
                                        }

                                        this.context = document;
                                        this.selector = selector;
                                        return this;
                                    }
                                } else if (!context) {
                                    return (context || rootjQuery).find(selector);
                                }
                            } else if (jQuery.isFunction(selector)) {
                                return rootjQuery.ready(selector);
                            }

                            if (selector.selector !== undefined) {
                                this.selector = selector.selector;
                                this.context = selector.context;
                            }

                            return jQuery.makeArray(selector, this);
                        },
                        selector: '',
                        jquery: '1.7.2',
                        length: 0,
                        size: function () {},
                        toArray: function () {
                            return slice.call(this, 0);
                        },
                        get: function (num) {
                            return num == null ? this.toArray() : 0;
                        },
                        pushStack: function (elems, name, selector) {
                            var ret = this.constructor();
                            if (jQuery.isArray(elems)) {
                                push.apply(ret, elems);
                            } else {
                                jQuery.merge(ret, elems);
                            }

                            ret.prevObject = this;
                            ret.context = this.context;
                            if (name === 'find') {
                                ret.selector = (this.selector + (this.selector ? 0 : '')) + selector;
                            } else if (name) {
                                ret.selector = ((((this.selector + '.') + name) + '(') + selector) + ')';
                            }

                            return ret;
                        },
                        each: function (callback, args) {
                            return jQuery.each(this, callback, args);
                        },
                        ready: function (fn) {
                            jQuery.bindReady();
                            readyList.add(fn);
                            return this;
                        },
                        eq: function (i) {
                            i = +i;
                            return i === -1 ? 0 : this.slice(i, i + 1);
                        },
                        first: function () {},
                        last: function () {},
                        slice: function () {
                            return this.pushStack(slice.apply(this, arguments), 'slice', slice.call(arguments).join(','));
                        },
                        map: function (callback) {
                            return this.pushStack(jQuery.map(this, function (elem, i) {
                                return callback.call(elem, i, elem);
                            }));
                        },
                        end: function () {},
                        push: push,
                        sort: ([]).sort,
                        splice: ([]).splice
                    };
                    jQuery.fn.init.prototype = jQuery.fn;
                    jQuery.extend = jQuery.fn.extend = function () {
                        var options, name, src, copy, copyIsArray, clone, target = arguments[0] || {}, i = 1,
                            length = arguments.length,
                            deep = false;
                        if (typeof target === 'boolean') {
                            deep = target;
                            target = arguments[1];
                            i = 2;
                        }

                        if (typeof target !== 'object' && !(jQuery.isFunction(target)));

                        if (length === i) {
                            target = this;
                            --i;
                        }

                        for (; i < length; i++) {
                            if ((options = arguments[i]) != null) {
                                for (name in options) {
                                    src = target[name];
                                    copy = options[name];
                                    if (target === copy);

                                    if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)))) {
                                        if (copyIsArray);
                                        else {
                                            clone = src && jQuery.isPlainObject(src) ? src : 0;
                                        }

                                        target[name] = jQuery.extend(deep, clone, copy);
                                    } else if (copy !== undefined) {
                                        target[name] = copy;
                                    }
                                }
                            }
                        }

                        return target;
                    };
                    jQuery.extend({
                        noConflict: function (deep) {},
                        isReady: false,
                        readyWait: 1,
                        holdReady: function (hold) {},
                        ready: function (wait) {
                            if (wait === true || (wait !== true && !(jQuery.isReady))) {
                                if (!(document.body));

                                jQuery.isReady = true;
                                if (wait !== true && --jQuery.readyWait > 0);

                                readyList.fireWith(document, [jQuery]);
                                if (jQuery.fn.trigger) {
                                    jQuery(document).trigger('ready').off('ready');
                                }
                            }
                        },
                        bindReady: function () {
                            if (readyList) {
                                return;
                            }

                            readyList = jQuery.Callbacks('once memory');
                            if (document.readyState === 'complete');

                            if (document.addEventListener) {
                                document.addEventListener('DOMContentLoaded', DOMContentLoaded, false);
                                window.addEventListener('load', jQuery.ready, false);
                            } else if (false) {
                                var toplevel;
                            }
                        },
                        isFunction: function (obj) {
                            return jQuery.type(obj) === 'function';
                        },
                        isArray: Array.isArray || function (obj) {
                            return jQuery.type(obj) === 'array';
                        },
                        isWindow: function (obj) {
                            return obj != null && obj == obj.window;
                        },
                        isNumeric: function (obj) {},
                        type: function (obj) {
                            return obj == null ? 0 : class2type[toString.call(obj)] || 'object';
                        },
                        isPlainObject: function (obj) {
                            if (!obj || jQuery.type(obj) !== 'object' || obj.nodeType || jQuery.isWindow(obj)) {
                                return false;
                            }

                            try {
                                if (obj.constructor && !(hasOwn.call(obj, 'constructor')) && !(hasOwn.call(obj.constructor.prototype, 'isPrototypeOf')));
                            } catch (e) {}
                            var key;
                            return key === undefined || hasOwn.call(obj, key);
                        },
                        isEmptyObject: function (obj) {
                            for (var name in obj) {
                                return false;
                            }
                        },
                        error: function (msg) {},
                        parseJSON: function (data) {},
                        parseXML: function (data) {},
                        noop: function () {},
                        globalEval: function (data) {},
                        camelCase: function (string) {
                            return string.replace(rmsPrefix, 'ms-').replace(rdashAlpha, fcamelCase);
                        },
                        nodeName: function (elem, name) {
                            return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
                        },
                        each: function (object, callback, args) {
                            var name, i = 0,
                                length = object.length,
                                isObj = length === undefined || jQuery.isFunction(object);
                            if (args);
                            else {
                                if (isObj) {
                                    for (name in object) {
                                        if (callback.call(object[name], name, object[name]) === false);
                                    }
                                } else {
                                    for (; i < length;) {
                                        if (callback.call(object[i], i, object[i++]) === false);
                                    }
                                }
                            }

                            return object;
                        },
                        trim: trim ? function (text) {
                            return text == null ? 0 : trim.call(text);
                        } : 0,
                        makeArray: function (array, results) {
                            var ret = results || [];
                            if (array != null) {
                                var type = jQuery.type(array);
                                if (array.length == null || type === 'string' || type === 'function' || type === 'regexp' || jQuery.isWindow(array)) {
                                    push.call(ret, array);
                                } else {
                                    jQuery.merge(ret, array);
                                }
                            }

                            return ret;
                        },
                        inArray: function (elem, array, i) {},
                        merge: function (first, second) {
                            var i = first.length,
                                j = 0;
                            if (typeof (second.length) === 'number') {
                                for (var l = second.length; j < l; j++) {
                                    first[i++] = second[j];
                                }
                            }

                            first.length = i;
                            return first;
                        },
                        grep: function (elems, callback, inv) {
                            var ret = [],
                                retVal;
                            inv = !(!inv);
                            for (var i = 0, length = elems.length; i < length; i++);
                            return ret;
                        },
                        map: function (elems, callback, arg) {
                            var value, key, ret = [],
                                i = 0,
                                length = elems.length,
                                isArray = elems instanceof jQuery;
                            if (isArray) {
                                for (; i < length; i++) {
                                    value = callback(elems[i], i, arg);
                                    if (value != null) {
                                        ret[ret.length] = value;
                                    }
                                }
                            }

                            return ret.concat.apply([], ret);
                        },
                        guid: 1,
                        proxy: function (fn, context) {},
                        access: function (elems, fn, key, value, chainable, emptyGet, pass) {
                            var exec, bulk = key == null,
                                i = 0,
                                length = elems.length;
                            if (key && typeof key === 'object');
                            else if (value !== undefined) {
                                exec = pass === undefined && jQuery.isFunction(value);
                                if (bulk) {
                                    if (exec);
                                    else {
                                        fn.call(elems, value);
                                        fn = null;
                                    }
                                }

                                if (fn) {
                                    for (; i < length; i++) {
                                        fn(elems[i], key, exec ? 0 : value, pass);
                                    }
                                }

                                chainable = 1;
                            }

                            return chainable ? elems : bulk ? 0 : length ? fn(elems[0], key) : 0;
                        },
                        now: function () {
                            return (new Date()).getTime();
                        },
                        uaMatch: function (ua) {
                            ua = ua.toLowerCase();
                            var match = rwebkit.exec(ua) || ropera.exec(ua) || rmsie.exec(ua) || (ua.indexOf('compatible') < 0 && rmozilla.exec(ua));
                            return {
                                browser: match[1],
                                version: match[2]
                            };
                        },
                        sub: function () {},
                        browser: {}
                    });
                    jQuery.each('Boolean Number String Function Array Date RegExp Object'.split(' '), function (i, name) {
                        class2type[('[object ' + name) + ']'] = name.toLowerCase();
                    });
                    browserMatch = jQuery.uaMatch(userAgent);
                    if (browserMatch.browser) {
                        jQuery.browser[browserMatch.browser] = true;
                        jQuery.browser.version = browserMatch.version;
                    }

                    if (jQuery.browser.webkit);

                    if (rnotwhite.test(' '));

                    rootjQuery = jQuery(document);
                    if (document.addEventListener) {
                        DOMContentLoaded = function () {
                            document.removeEventListener('DOMContentLoaded', DOMContentLoaded, false);
                            jQuery.ready();
                        };
                    }

                    function doScrollCheck() {}
                    return jQuery;
                })();
                var flagsCache = {};

                function createFlags(flags) {
                    var object = flagsCache[flags] = {}, i, length;
                    flags = flags.split(/\s+/);
                    for (i = 0, length = flags.length; i < length; i++) {
                        object[flags[i]] = true;
                    }

                    return object;
                }
                jQuery.Callbacks = function (flags) {
                    flags = flags ? flagsCache[flags] || createFlags(flags) : 0;
                    var list = [],
                        stack = [],
                        memory, fired, firing, firingStart, firingLength, firingIndex, add = function (args) {
                            var i, length, elem, type, actual;
                            for (i = 0, length = args.length; i < length; i++) {
                                elem = args[i];
                                type = jQuery.type(elem);
                                if (type === 'array');
                                else if (type === 'function') {
                                    if (!(flags.unique)) {
                                        list.push(elem);
                                    }
                                }
                            }
                        }, fire = function (context, args) {
                            args = args;
                            memory = !(flags.memory) || [context, args];
                            fired = true;
                            firing = true;
                            firingIndex = firingStart || 0;
                            firingStart = 0;
                            firingLength = list.length;
                            for (; list && firingIndex < firingLength; firingIndex++) {
                                if (list[firingIndex].apply(context, args) === false);
                            }

                            firing = false;
                            if (list) {
                                if (!(flags.once));
                                else if (memory === true);
                                else {
                                    list = [];
                                }
                            }
                        }, self = {
                            add: function () {
                                if (list) {
                                    var length = list.length;
                                    add(arguments);
                                    if (firing);
                                    else if (memory);
                                }

                                return this;
                            },
                            remove: function () {},
                            has: function (fn) {},
                            empty: function () {},
                            disable: function () {},
                            disabled: function () {},
                            lock: function () {},
                            locked: function () {},
                            fireWith: function (context, args) {
                                if (stack) {
                                    if (firing);
                                    else if (!(flags.once && memory)) {
                                        fire(context, args);
                                    }
                                }

                                return this;
                            },
                            fire: function () {},
                            fired: function () {}
                        };
                    return self;
                };
                var sliceDeferred = ([]).slice;
                jQuery.extend({
                    Deferred: function (func) {},
                    when: function (firstParam) {}
                });
                jQuery.support = (function () {
                    var support, all, a, select, opt, input, fragment, tds, events, eventName, i, isSupported, div = document.createElement('div'),
                        documentElement = document.documentElement;
                    div.setAttribute('className', 't');
                    div.innerHTML = '   <link/><table></table><a href=\'/a\' style=\'top:1px;float:left;opacity:.55;\'>a</a><input type=\'checkbox\'/>';
                    all = div.getElementsByTagName('*');
                    a = div.getElementsByTagName('a')[0];
                    if (!all || !(all.length) || !a);

                    select = document.createElement('select');
                    opt = select.appendChild(document.createElement('option'));
                    input = div.getElementsByTagName('input')[0];
                    support = {
                        leadingWhitespace: div.firstChild.nodeType === 3,
                        tbody: !(div.getElementsByTagName('tbody').length),
                        htmlSerialize: !(!(div.getElementsByTagName('link').length)),
                        style: /top/.test(a.getAttribute('style')),
                        hrefNormalized: a.getAttribute('href') === '/a',
                        opacity: /^0.55/.test(a.style.opacity),
                        cssFloat: !(!(a.style.cssFloat)),
                        checkOn: input.value === 'on',
                        optSelected: opt.selected,
                        getSetAttribute: div.className !== 't',
                        enctype: !(!(document.createElement('form').enctype)),
                        html5Clone: document.createElement('nav').cloneNode(true).outerHTML !== '<:nav></:nav>',
                        submitBubbles: true,
                        changeBubbles: true,
                        focusinBubbles: false,
                        deleteExpando: true,
                        noCloneEvent: true,
                        inlineBlockNeedsLayout: false,
                        shrinkWrapBlocks: false,
                        reliableMarginRight: true,
                        pixelMargin: true
                    };
                    jQuery.boxModel = support.boxModel = document.compatMode === 'CSS1Compat';
                    input.checked = true;
                    support.noCloneChecked = input.cloneNode(true).checked;
                    select.disabled = true;
                    support.optDisabled = !(opt.disabled);
                    try {
                        delete(div.test);
                    } catch (e) {}
                    if (!(div.addEventListener));

                    input = document.createElement('input');
                    input.value = 't';
                    input.setAttribute('type', 'radio');
                    support.radioValue = input.value === 't';
                    input.setAttribute('checked', 'checked');
                    input.setAttribute('name', 't');
                    div.appendChild(input);
                    fragment = document.createDocumentFragment();
                    fragment.appendChild(div.lastChild);
                    support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;
                    support.appendChecked = input.checked;
                    fragment.removeChild(input);
                    fragment.appendChild(div);
                    if (div.attachEvent);

                    fragment.removeChild(div);
                    fragment = select = opt = div = input = null;
                    jQuery(function () {
                        var container, outer, inner, table, td, offsetSupport, marginDiv, conMarginTop, style, html, positionTopLeftWidthHeight, paddingMarginBorderVisibility, paddingMarginBorder, body = document.getElementsByTagName('body')[0];
                        if (!body);

                        conMarginTop = 1;
                        paddingMarginBorder = 'padding:0;margin:0;border:';
                        positionTopLeftWidthHeight = 'position:absolute;top:0;left:0;width:1px;height:1px;';
                        paddingMarginBorderVisibility = paddingMarginBorder + '0;visibility:hidden;';
                        style = (('style=\'' + positionTopLeftWidthHeight) + paddingMarginBorder) + '5px solid #000;';
                        html = ((((((('<div ' + style) + 'display:block;\'><div style=\'') + paddingMarginBorder) + '0;display:block;overflow:hidden;\'></div></div>') + '<table ') + style) + '\' cellpadding=\'0\' cellspacing=\'0\'>') + '<tr><td></td></tr></table>';
                        container = document.createElement('div');
                        container.style.cssText = ((paddingMarginBorderVisibility + 'width:0;height:0;position:static;top:0;margin-top:') + conMarginTop) + 'px';
                        body.insertBefore(container, body.firstChild);
                        div = document.createElement('div');
                        container.appendChild(div);
                        div.innerHTML = ('<table><tr><td style=\'' + paddingMarginBorder) + '0;display:none\'></td><td>t</td></tr></table>';
                        tds = div.getElementsByTagName('td');
                        isSupported = tds[0].offsetHeight === 0;
                        tds[0].style.display = '';
                        tds[1].style.display = 'none';
                        support.reliableHiddenOffsets = isSupported && tds[0].offsetHeight === 0;
                        if (window.getComputedStyle) {
                            div.innerHTML = '';
                            marginDiv = document.createElement('div');
                            marginDiv.style.width = '0';
                            marginDiv.style.marginRight = '0';
                            div.style.width = '2px';
                            div.appendChild(marginDiv);
                            support.reliableMarginRight = (parseInt((window.getComputedStyle(marginDiv, null)).marginRight, 10) || 0) === 0;
                        }

                        if (typeof (div.style.zoom) !== 'undefined');

                        div.style.cssText = positionTopLeftWidthHeight + paddingMarginBorderVisibility;
                        div.innerHTML = html;
                        outer = div.firstChild;
                        inner = outer.firstChild;
                        td = outer.nextSibling.firstChild.firstChild;
                        offsetSupport = {
                            doesNotAddBorder: inner.offsetTop !== 5,
                            doesAddBorderForTableAndCells: td.offsetTop === 5
                        };
                        inner.style.position = 'fixed';
                        inner.style.top = '20px';
                        offsetSupport.fixedPosition = inner.offsetTop === 20;
                        inner.style.position = inner.style.top = '';
                        outer.style.overflow = 'hidden';
                        outer.style.position = 'relative';
                        offsetSupport.subtractsBorderForOverflowNotVisible = inner.offsetTop === -5;
                        offsetSupport.doesNotIncludeMarginInBodyOffset = body.offsetTop !== conMarginTop;
                        if (window.getComputedStyle) {
                            div.style.marginTop = '1%';
                            support.pixelMargin = (window.getComputedStyle(div, null)).marginTop !== '1%';
                        }

                        if (typeof (container.style.zoom) !== 'undefined');

                        body.removeChild(container);
                        marginDiv = div = container = null;
                        jQuery.extend(support, offsetSupport);
                    });
                    return support;
                })();
                var rbrace = /^(?:\{.*\}|\[.*\])$/,
                    rmultiDash = /([A-Z])/g;
                jQuery.extend({
                    cache: {},
                    uuid: 0,
                    expando: 'jQuery' + (jQuery.fn.jquery + Math.random()).replace(/\D/g, ''),
                    noData: {
                        'embed': true,
                        'object': 'clsid:D27CDB6E-AE6D-11cf-96B8-444553540000',
                        'applet': true
                    },
                    hasData: function (elem) {
                        elem = elem.nodeType ? jQuery.cache[elem[jQuery.expando]] : 0;
                        return !(!elem);
                    },
                    data: function (elem, name, data, pvt) {
                        if (!(jQuery.acceptData(elem)));

                        var privateCache, thisCache, ret, internalKey = jQuery.expando,
                            getByName = typeof name === 'string',
                            isNode = elem.nodeType,
                            cache = isNode ? jQuery.cache : elem,
                            id = isNode ? elem[internalKey] : elem[internalKey],
                            isEvents = name === 'events';
                        if ((!id || !(cache[id]) || !isEvents && !pvt) && getByName && data === undefined) {
                            return;
                        }

                        if (!id) {
                            if (isNode) {
                                elem[internalKey] = id = ++jQuery.uuid;
                            } else {
                                id = internalKey;
                            }
                        }

                        if (!(cache[id])) {
                            cache[id] = {};
                            if (!isNode) {
                                cache[id].toJSON = jQuery.noop;
                            }
                        }

                        if (typeof name === 'object' || typeof name === 'function');

                        privateCache = thisCache = cache[id];
                        if (!pvt);

                        if (data !== undefined) {
                            thisCache[jQuery.camelCase(name)] = data;
                        }

                        if (isEvents && !(thisCache[name]));

                        if (getByName) {
                            ret = thisCache[name];
                            if (ret == null) {
                                ret = thisCache[jQuery.camelCase(name)];
                            }
                        } else {
                            ret = thisCache;
                        }

                        return ret;
                    },
                    removeData: function (elem, name, pvt) {
                        if (!(jQuery.acceptData(elem)));

                        var thisCache, i, l, internalKey = jQuery.expando,
                            isNode = elem.nodeType,
                            cache = isNode ? jQuery.cache : 0,
                            id = isNode ? elem[internalKey] : 0;
                        if (!(cache[id]));

                        if (name) {
                            thisCache = pvt ? cache[id] : 0;
                            if (thisCache) {
                                if (!(jQuery.isArray(name))) {
                                    if (name in thisCache);
                                    else {
                                        name = jQuery.camelCase(name);
                                        if (name in thisCache);
                                        else {
                                            name = name.split(' ');
                                        }
                                    }
                                }

                                for (i = 0, l = name.length; i < l; i++) {
                                    delete(thisCache[name[i]]);
                                }

                                if (!((pvt ? isEmptyDataObject : 0)(thisCache))) {
                                    return;
                                }
                            }
                        }
                    },
                    _data: function (elem, name, data) {
                        return jQuery.data(elem, name, data, true);
                    },
                    acceptData: function (elem) {
                        if (elem.nodeName) {
                            var match = jQuery.noData[elem.nodeName.toLowerCase()];
                            if (match);
                        }

                        return true;
                    }
                });
                jQuery.fn.extend({
                    data: function (key, value) {},
                    removeData: function (key) {}
                });

                function dataAttr(elem, key, data) {}

                function isEmptyDataObject(obj) {
                    for (var name in obj) {
                        if (name === 'data');

                        if (name !== 'toJSON') {
                            return false;
                        }
                    }
                }

                function handleQueueMarkDefer(elem, type, src) {}
                jQuery.extend({
                    _mark: function (elem, type) {},
                    _unmark: function (force, elem, type) {},
                    queue: function (elem, type, data) {
                        var q;
                        if (elem) {
                            type = type + 'queue';
                            q = jQuery._data(elem, type);
                            if (data) {
                                if (!q || jQuery.isArray(data)) {
                                    q = jQuery._data(elem, type, jQuery.makeArray(data));
                                } else {
                                    q.push(data);
                                }
                            }

                            return q;
                        }
                    },
                    dequeue: function (elem, type) {
                        type = type || 'fx';
                        var queue = jQuery.queue(elem, type),
                            fn = queue.shift(),
                            hooks = {};
                        if (fn === 'inprogress') {
                            fn = queue.shift();
                        }

                        if (fn) {
                            if (type === 'fx') {
                                queue.unshift('inprogress');
                            }

                            jQuery._data(elem, type + '.run', hooks);
                            fn.call(elem, function () {}, hooks);
                        }

                        if (!(queue.length));
                    }
                });
                jQuery.fn.extend({
                    queue: function (type, data) {
                        var setter = 2;
                        if (typeof type !== 'string');

                        if (arguments.length < setter);

                        return data === undefined ? 0 : this.each(function () {
                            var queue = jQuery.queue(this, type, data);
                            if (type === 'fx' && queue[0] !== 'inprogress') {
                                jQuery.dequeue(this, type);
                            }
                        });
                    },
                    dequeue: function (type) {},
                    delay: function (time, type) {},
                    clearQueue: function (type) {},
                    promise: function (type, object) {}
                });
                var rclass = /[\n\t\r]/g,
                    rspace = /\s+/,
                    rreturn = /\r/g,
                    rtype = /^(?:button|input)$/i,
                    rfocusable = /^(?:button|input|object|select|textarea)$/i,
                    rclickable = /^a(?:rea)?$/i,
                    rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
                    getSetAttribute = jQuery.support.getSetAttribute,
                    nodeHook, boolHook, fixSpecified;
                jQuery.fn.extend({
                    attr: function (name, value) {
                        return jQuery.access(this, jQuery.attr, name, value, arguments.length > 1);
                    },
                    removeAttr: function (name) {},
                    prop: function (name, value) {},
                    removeProp: function (name) {},
                    addClass: function (value) {
                        var classNames, i, l, elem, setClass, c, cl;
                        if (jQuery.isFunction(value));

                        if (value && typeof value === 'string') {
                            classNames = value.split(rspace);
                            for (i = 0, l = this.length; i < l; i++) {
                                elem = this[i];
                                if (elem.nodeType === 1) {
                                    if (!(elem.className));
                                    else {
                                        setClass = (' ' + elem.className) + ' ';
                                        for (c = 0, cl = classNames.length; c < cl; c++) {
                                            if (!(~(setClass.indexOf((' ' + classNames[c]) + ' ')))) {
                                                setClass += classNames[c] + ' ';
                                            }
                                        }

                                        elem.className = jQuery.trim(setClass);
                                    }
                                }
                            }
                        }

                        return this;
                    },
                    removeClass: function (value) {
                        var classNames, i, l, elem, className, c, cl;
                        if (jQuery.isFunction(value));

                        if ((value && typeof value === 'string')) {
                            classNames = (value).split(rspace);
                            for (i = 0, l = this.length; i < l; i++) {
                                elem = this[i];
                                if (elem.nodeType === 1 && elem.className) {
                                    if (value) {
                                        className = ((' ' + elem.className) + ' ').replace(rclass, ' ');
                                        for (c = 0, cl = classNames.length; c < cl; c++) {
                                            className = className.replace((' ' + classNames[c]) + ' ', ' ');
                                        }

                                        elem.className = jQuery.trim(className);
                                    }
                                }
                            }
                        }

                        return this;
                    },
                    toggleClass: function (value, stateVal) {},
                    hasClass: function (selector) {
                        var className = (' ' + selector) + ' ',
                            i = 0,
                            l = this.length;
                        for (; i < l; i++) {
                            if (this[i].nodeType === 1 && ((' ' + this[i].className) + ' ').replace(rclass, ' ').indexOf(className) > -1) {
                                return true;
                            }
                        }

                        return false;
                    },
                    val: function (value) {}
                });
                jQuery.extend({
                    valHooks: {
                        option: {
                            get: function (elem) {}
                        },
                        select: {
                            get: function (elem) {},
                            set: function (elem, value) {}
                        }
                    },
                    attrFn: {
                        val: true,
                        css: true,
                        html: true,
                        text: true,
                        data: true,
                        width: true,
                        height: true,
                        offset: true
                    },
                    attr: function (elem, name, value, pass) {
                        var ret, hooks, notxml, nType = elem.nodeType;
                        if (!elem || nType === 3 || nType === 8 || nType === 2);

                        if (pass);

                        if (typeof (elem.getAttribute) === 'undefined');

                        notxml = nType !== 1 || !(jQuery.isXMLDoc(elem));
                        if (notxml) {
                            name = name.toLowerCase();
                            hooks = jQuery.attrHooks[name] || (rboolean.test(name) ? 0 : nodeHook);
                        }

                        if (value !== undefined);
                        else if (hooks);
                        else {
                            ret = elem.getAttribute(name);
                            return ret === null ? undefined : 0;
                        }
                    },
                    removeAttr: function (elem, value) {},
                    attrHooks: {
                        type: {
                            set: function (elem, value) {}
                        },
                        value: {
                            get: function (elem, name) {},
                            set: function (elem, value, name) {}
                        }
                    },
                    propFix: {
                        tabindex: 'tabIndex',
                        readonly: 'readOnly',
                        'for': 'htmlFor',
                        'class': 'className',
                        maxlength: 'maxLength',
                        cellspacing: 'cellSpacing',
                        cellpadding: 'cellPadding',
                        rowspan: 'rowSpan',
                        colspan: 'colSpan',
                        usemap: 'useMap',
                        frameborder: 'frameBorder',
                        contenteditable: 'contentEditable'
                    },
                    prop: function (elem, name, value) {},
                    propHooks: {
                        tabIndex: {
                            get: function (elem) {}
                        }
                    }
                });
                jQuery.attrHooks.tabindex = jQuery.propHooks.tabIndex;
                boolHook = {
                    get: function (elem, name) {},
                    set: function (elem, value, name) {}
                };
                if (!getSetAttribute);

                if (!(jQuery.support.hrefNormalized));

                if (!(jQuery.support.style));

                if (!(jQuery.support.optSelected)) {
                    jQuery.propHooks.selected = jQuery.extend(jQuery.propHooks.selected, {
                        get: function (elem) {}
                    });
                }

                if (!(jQuery.support.enctype));

                if (!(jQuery.support.checkOn));

                jQuery.each(['radio', 'checkbox'], function () {
                    jQuery.valHooks[this] = jQuery.extend(jQuery.valHooks[this], {
                        set: function (elem, value) {}
                    });
                });
                var rformElems = /^(?:textarea|input|select)$/i,
                    rtypenamespace = /^([^\.]*)?(?:\.(.+))?$/,
                    rhoverHack = /(?:^|\s)hover(\.\S+)?\b/,
                    rkeyEvent = /^key/,
                    rmouseEvent = /^(?:mouse|contextmenu)|click/,
                    rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
                    rquickIs = /^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,
                    quickParse = function (selector) {}, quickIs = function (elem, m) {}, hoverHack = function (events) {
                        return jQuery.event.special.hover ? 0 : events.replace(rhoverHack, 'mouseenter$1 mouseleave$1');
                    };
                jQuery.event = {
                    add: function (elem, types, handler, data, selector) {
                        var elemData, eventHandle, events, t, tns, type, namespaces, handleObj, handleObjIn, quick, handlers, special;
                        if (elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data(elem)));

                        if (handler.handler);

                        if (!(handler.guid)) {
                            handler.guid = jQuery.guid++;
                        }

                        events = elemData.events;
                        if (!events) {
                            elemData.events = events = {};
                        }

                        eventHandle = elemData.handle;
                        if (!eventHandle) {
                            elemData.handle = eventHandle = function (e) {
                                return typeof jQuery !== 'undefined' && (!e || jQuery.event.triggered !== e.type) ? jQuery.event.dispatch.apply(eventHandle.elem, arguments) : 0;
                            };
                            eventHandle.elem = elem;
                        }

                        types = jQuery.trim(hoverHack(types)).split(' ');
                        for (t = 0; t < types.length; t++) {
                            tns = rtypenamespace.exec(types[t]);
                            type = tns[1];
                            namespaces = (tns[2] || '').split('.').sort();
                            special = jQuery.event.special[type] || {};
                            type = (selector ? 0 : special.bindType) || type;
                            special = jQuery.event.special[type] || {};
                            handleObj = jQuery.extend({
                                type: type,
                                origType: tns[1],
                                data: data,
                                handler: handler,
                                guid: handler.guid,
                                selector: selector,
                                quick: selector,
                                namespace: namespaces.join('.')
                            }, handleObjIn);
                            handlers = events[type];
                            if (!handlers) {
                                handlers = events[type] = [];
                                handlers.delegateCount = 0;
                                if (!(special.setup)) {
                                    if (elem.addEventListener) {
                                        elem.addEventListener(type, eventHandle, false);
                                    }
                                }
                            }

                            if (special.add);

                            if (selector);
                            else {
                                handlers.push(handleObj);
                            }

                            jQuery.event.global[type] = true;
                        }

                        elem = null;
                    },
                    global: {},
                    remove: function (elem, types, handler, selector, mappedTypes) {
                        var elemData = jQuery.hasData(elem),
                            t, tns, type, origType, namespaces, origCount, j, events, special, handle, eventType, handleObj;
                        if (!elemData) {
                            return;
                        }
                    },
                    customEvent: {
                        'getData': true,
                        'setData': true,
                        'changeData': true
                    },
                    trigger: function (event, data, elem, onlyHandlers) {
                        if (elem && (elem.nodeType === 3 || elem.nodeType === 8));

                        var type = event.type || event,
                            namespaces = [],
                            cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType;
                        if (rfocusMorph.test(type + jQuery.event.triggered));

                        if (type.indexOf('!') >= 0);

                        if (type.indexOf('.') >= 0);

                        if ((!elem || jQuery.event.customEvent[type]));

                        event = typeof event === 'object' ? 0 : new jQuery.Event(type);
                        event.type = type;
                        event.isTrigger = true;
                        event.exclusive = exclusive;
                        event.namespace = namespaces.join('.');
                        event.namespace_re = event.namespace ? 0 : null;
                        ontype = type.indexOf(':') < 0 ? 'on' + type : 0;
                        if (!elem);

                        event.result = undefined;
                        if (!(event.target)) {
                            event.target = elem;
                        }

                        data = data != null ? 0 : [];
                        data.unshift(event);
                        special = jQuery.event.special[type];
                        if (special.trigger);

                        eventPath = [
                            [elem, special.bindType || type]
                        ];
                        if (!onlyHandlers && !(special.noBubble) && !(jQuery.isWindow(elem))) {
                            bubbleType = special.delegateType || type;
                            cur = rfocusMorph.test(bubbleType + type) ? 0 : elem.parentNode;
                            old = null;
                            for (; cur; cur = cur.parentNode);
                            if (old);
                        }

                        for (i = 0; i < eventPath.length && !(event.isPropagationStopped()); i++) {
                            cur = eventPath[i][0];
                            event.type = eventPath[i][1];
                            handle = (jQuery._data(cur, 'events') || {})[event.type];
                            if (handle);

                            handle = ontype && cur[ontype];
                            if (handle);
                        }

                        event.type = type;
                        if (!onlyHandlers && !(event.isDefaultPrevented())) {
                            if (!(special._default) && !(type === 'click') && jQuery.acceptData(elem)) {
                                if (ontype && elem[type]);
                            }
                        }

                        return event.result;
                    },
                    dispatch: function (event) {
                        event = jQuery.event.fix(event);
                        var handlers = (jQuery._data(this, 'events'))[event.type],
                            delegateCount = handlers.delegateCount,
                            args = ([]).slice.call(arguments, 0),
                            run_all = !(event.exclusive) && !(event.namespace),
                            special = jQuery.event.special[event.type] || {}, handlerQueue = [],
                            i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related;
                        args[0] = event;
                        event.delegateTarget = this;
                        if (special.preDispatch);

                        if (delegateCount);

                        if (handlers.length > delegateCount) {
                            handlerQueue.push({
                                elem: this,
                                matches: handlers.slice(delegateCount)
                            });
                        }

                        for (i = 0; i < handlerQueue.length && !(event.isPropagationStopped()); i++) {
                            matched = handlerQueue[i];
                            event.currentTarget = matched.elem;
                            for (j = 0; j < matched.matches.length && !(event.isImmediatePropagationStopped()); j++) {
                                handleObj = matched.matches[j];
                                if (run_all) {
                                    event.data = handleObj.data;
                                    event.handleObj = handleObj;
                                    ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args);
                                    if (ret !== undefined) {
                                        event.result = ret;
                                        if (ret === false) {
                                            event.preventDefault();
                                            event.stopPropagation();
                                        }
                                    }
                                }
                            }
                        }

                        if (special.postDispatch);

                        return event.result;
                    },
                    props: 'attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which'.split(' '),
                    fixHooks: {},
                    keyHooks: {
                        props: 'char charCode key keyCode'.split(' '),
                        filter: function (event, original) {}
                    },
                    mouseHooks: {
                        props: 'button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement'.split(' '),
                        filter: function (event, original) {
                            var eventDoc, doc, body, button = original.button,
                                fromElement = original.fromElement;
                            if (event.pageX == null);

                            if (!(event.relatedTarget) && fromElement);

                            if (!(event.which) && button !== undefined);

                            return event;
                        }
                    },
                    fix: function (event) {
                        if (event[jQuery.expando]);

                        var i, prop, originalEvent = event,
                            fixHook = jQuery.event.fixHooks[event.type],
                            copy = fixHook.props ? this.props.concat(fixHook.props) : 0;
                        event = jQuery.Event(originalEvent);
                        for (i = copy.length; i;) {
                            prop = copy[--i];
                            event[prop] = originalEvent[prop];
                        }

                        if (!(event.target)) {
                            event.target = originalEvent.srcElement || document;
                        }

                        if (event.target.nodeType === 3);

                        if (event.metaKey === undefined) {
                            event.metaKey = event.ctrlKey;
                        }

                        return fixHook.filter ? fixHook.filter(event, originalEvent) : 0;
                    },
                    special: {
                        ready: {
                            setup: jQuery.bindReady
                        },
                        load: {
                            noBubble: true
                        },
                        focus: {
                            delegateType: 'focusin'
                        },
                        blur: {
                            delegateType: 'focusout'
                        },
                        beforeunload: {
                            setup: function (data, namespaces, eventHandle) {},
                            teardown: function (namespaces, eventHandle) {}
                        }
                    },
                    simulate: function (type, elem, event, bubble) {}
                };
                jQuery.event.handle = jQuery.event.dispatch;
                jQuery.removeEvent = document.removeEventListener ? function (elem, type, handle) {} : 0;
                jQuery.Event = function (src, props) {
                    if (!(this instanceof jQuery.Event)) {
                        return new jQuery.Event(src, props);
                    }

                    if (src && src.type) {
                        this.originalEvent = src;
                        this.type = src.type;
                        this.isDefaultPrevented = src.defaultPrevented || src.returnValue === false || src.getPreventDefault ? 0 : returnFalse;
                    } else {
                        this.type = src;
                    }

                    if (props);

                    this.timeStamp = (src && src.timeStamp) || jQuery.now();
                    this[jQuery.expando] = true;
                };

                function returnFalse() {
                    return false;
                }

                function returnTrue() {}
                jQuery.Event.prototype = {
                    preventDefault: function () {
                        this.isDefaultPrevented = returnTrue;
                        var e = this.originalEvent;
                        if (!e);

                        if (e.preventDefault) {
                            e.preventDefault();
                        }
                    },
                    stopPropagation: function () {
                        this.isPropagationStopped = returnTrue;
                        var e = this.originalEvent;
                        if (!e);

                        if (e.stopPropagation) {
                            e.stopPropagation();
                        }

                        e.cancelBubble = true;
                    },
                    stopImmediatePropagation: function () {},
                    isDefaultPrevented: returnFalse,
                    isPropagationStopped: returnFalse,
                    isImmediatePropagationStopped: returnFalse
                };
                jQuery.each({
                    mouseenter: 'mouseover',
                    mouseleave: 'mouseout'
                }, function (orig, fix) {
                    jQuery.event.special[orig] = {
                        delegateType: fix,
                        bindType: fix,
                        handle: function (event) {
                            var target = this,
                                related = event.relatedTarget,
                                handleObj = event.handleObj,
                                selector = handleObj.selector,
                                ret;
                            if (!related || (related !== target && !(jQuery.contains(target, related)))) {
                                event.type = handleObj.origType;
                                ret = handleObj.handler.apply(this, arguments);
                                event.type = fix;
                            }

                            return ret;
                        }
                    };
                });
                if (!(jQuery.support.submitBubbles));

                if (!(jQuery.support.changeBubbles));

                if (!(jQuery.support.focusinBubbles)) {
                    jQuery.each({
                        focus: 'focusin',
                        blur: 'focusout'
                    }, function (orig, fix) {
                        var attaches = 0,
                            handler = function (event) {};
                        jQuery.event.special[fix] = {
                            setup: function () {},
                            teardown: function () {}
                        };
                    });
                }

                jQuery.fn.extend({
                    on: function (types, selector, data, fn, one) {
                        var origFn, type;
                        if (typeof types === 'object');

                        if (data == null && fn == null);
                        else if (fn == null);

                        if (fn === false);
                        else if (!fn);

                        if (one === 1);

                        return this.each(function () {
                            jQuery.event.add(this, types, fn, data, selector);
                        });
                    },
                    one: function (types, selector, data, fn) {},
                    off: function (types, selector, fn) {
                        if (types && types.preventDefault) {
                            var handleObj;
                        }

                        if (typeof types === 'object') {
                            for (var type in types);
                        }

                        if (selector === false || typeof selector === 'function');

                        if (fn === false);

                        return this.each(function () {
                            jQuery.event.remove(this, types, fn, selector);
                        });
                    },
                    bind: function (types, data, fn) {
                        return this.on(types, null, data, fn);
                    },
                    unbind: function (types, fn) {},
                    live: function (types, data, fn) {},
                    die: function (types, fn) {},
                    delegate: function (selector, types, data, fn) {},
                    undelegate: function (selector, types, fn) {},
                    trigger: function (type, data) {
                        return this.each(function () {
                            jQuery.event.trigger(type, data, this);
                        });
                    },
                    triggerHandler: function (type, data) {},
                    toggle: function (fn) {},
                    hover: function (fnOver, fnOut) {
                        return this.mouseenter(fnOver).mouseleave(fnOut);
                    }
                });
                jQuery.each((('blur focus focusin focusout load resize scroll unload click dblclick ' + 'mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave ') + 'change select submit keydown keypress keyup error contextmenu').split(' '), function (i, name) {
                    jQuery.fn[name] = function (data, fn) {
                        if (fn == null) {
                            fn = data;
                            data = null;
                        }

                        return arguments.length > 0 ? this.on(name, null, data, fn) : 0;
                    };
                    if (jQuery.attrFn) {
                        jQuery.attrFn[name] = true;
                    }

                    if (rkeyEvent.test(name)) {
                        jQuery.event.fixHooks[name] = jQuery.event.keyHooks;
                    }

                    if (rmouseEvent.test(name)) {
                        jQuery.event.fixHooks[name] = jQuery.event.mouseHooks;
                    }
                });
                (function () {
                    var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
                        expando = 'sizcache' + (Math.random() + '').replace('.', ''),
                        done = 0,
                        toString = Object.prototype.toString,
                        hasDuplicate = false,
                        baseHasDuplicate = true,
                        rBackslash = /\\/g,
                        rReturn = /\r\n/g,
                        rNonWord = /\W/;
                    ([0, 0]).sort(function () {
                        baseHasDuplicate = false;
                        return 0;
                    });
                    var Sizzle = function (selector, context, results, seed) {
                        results = results || [];
                        context = context;
                        var origContext = context;
                        if (context.nodeType !== 1 && context.nodeType !== 9);

                        if (!selector || typeof selector !== 'string');

                        var m, set, checkSet, extra, ret, cur, pop, i, prune = true,
                            contextXML = Sizzle.isXML(context),
                            parts = [],
                            soFar = selector;
                        do {
                            chunker.exec('');
                            m = chunker.exec(soFar);
                            if (m) {
                                soFar = m[3];
                                parts.push(m[1]);
                                if (m[2]);
                            }
                        }
                        while (m)
                        if (parts.length > 1);
                        else {
                            if (!seed);

                            if (context) {
                                ret = seed ? {
                                    expr: parts.pop(),
                                    set: makeArray(seed)
                                } : 0;
                                set = ret.expr ? Sizzle.filter(ret.expr, ret.set) : 0;
                                if (parts.length > 0);
                                else {
                                    prune = false;
                                }
                            }
                        }

                        if (!checkSet) {
                            checkSet = set;
                        }

                        if (!checkSet);

                        if (toString.call(checkSet) === '[object Array]') {
                            if (!prune) {
                                results.push.apply(results, checkSet);
                            }
                        }

                        if (extra);

                        return results;
                    };
                    Sizzle.uniqueSort = function (results) {};
                    Sizzle.matches = function (expr, set) {};
                    Sizzle.matchesSelector = function (node, expr) {};
                    Sizzle.find = function (expr, context, isXML) {};
                    Sizzle.filter = function (expr, set, inplace, not) {
                        var match, anyFound, type, found, item, filter, left, i, pass, old = expr,
                            result = [],
                            curLoop = set,
                            isXMLFilter = set && set[0] && Sizzle.isXML(set[0]);
                        while (expr && set.length) {
                            for (type in Expr.filter) {
                                if ((match = Expr.leftMatch[type].exec(expr)) != null && match[2]) {
                                    filter = Expr.filter[type];
                                    left = match[1];
                                    anyFound = false;
                                    match.splice(1, 1);
                                    if (left.substr(left.length - 1) === '\\');

                                    if (curLoop === result);

                                    if (Expr.preFilter[type]) {
                                        match = Expr.preFilter[type](match, curLoop, inplace, result, not, isXMLFilter);
                                        if (!match);
                                        else if (match === true);
                                    }

                                    if (match) {
                                        for (i = 0;
                                        (item = curLoop[i]) != null; i++) {
                                            if (item) {
                                                found = filter(item, match, i, curLoop);
                                                pass = not ^ found;
                                                if (inplace);
                                                else if (pass) {
                                                    result.push(item);
                                                    anyFound = true;
                                                }
                                            }
                                        }
                                    }

                                    if (found !== undefined) {
                                        if (!inplace) {
                                            curLoop = result;
                                        }

                                        expr = expr.replace(Expr.match[type], '');
                                        if (!anyFound) {
                                            return [];
                                        }

                                        break;
                                    }
                                }
                            }

                            if (expr === old);

                            old = expr;
                        }

                        return curLoop;
                    };
                    Sizzle.error = function (msg) {};
                    var getText = Sizzle.getText = function (elem) {};
                    var Expr = Sizzle.selectors = {
                        order: ['ID', 'NAME', 'TAG'],
                        match: {
                            ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
                            CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
                            NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
                            ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
                            TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
                            CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
                            POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
                            PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
                        },
                        leftMatch: {},
                        attrMap: {
                            'class': 'className',
                            'for': 'htmlFor'
                        },
                        attrHandle: {
                            href: function (elem) {},
                            type: function (elem) {}
                        },
                        relative: {
                            '+': function (checkSet, part) {},
                            '>': function (checkSet, part) {},
                            '': function (checkSet, part, isXML) {},
                            '~': function (checkSet, part, isXML) {}
                        },
                        find: {
                            ID: function (match, context, isXML) {},
                            NAME: function (match, context) {},
                            TAG: function (match, context) {}
                        },
                        preFilter: {
                            CLASS: function (match, curLoop, inplace, result, not, isXML) {},
                            ID: function (match) {},
                            TAG: function (match, curLoop) {},
                            CHILD: function (match) {},
                            ATTR: function (match, curLoop, inplace, result, not, isXML) {},
                            PSEUDO: function (match, curLoop, inplace, result, not) {
                                if (match[1] === 'not') {
                                    if (false);
                                    else {
                                        var ret;
                                    }
                                } else if (Expr.match.POS.test(match[0]) || Expr.match.CHILD.test(match[0]));

                                return match;
                            },
                            POS: function (match) {}
                        },
                        filters: {
                            enabled: function (elem) {},
                            disabled: function (elem) {},
                            checked: function (elem) {},
                            selected: function (elem) {},
                            parent: function (elem) {},
                            empty: function (elem) {},
                            has: function (elem, i, match) {},
                            header: function (elem) {},
                            text: function (elem) {},
                            radio: function (elem) {},
                            checkbox: function (elem) {},
                            file: function (elem) {},
                            password: function (elem) {},
                            submit: function (elem) {},
                            image: function (elem) {},
                            reset: function (elem) {},
                            button: function (elem) {},
                            input: function (elem) {},
                            focus: function (elem) {}
                        },
                        setFilters: {
                            first: function (elem, i) {},
                            last: function (elem, i, match, array) {},
                            even: function (elem, i) {},
                            odd: function (elem, i) {},
                            lt: function (elem, i, match) {},
                            gt: function (elem, i, match) {},
                            nth: function (elem, i, match) {},
                            eq: function (elem, i, match) {}
                        },
                        filter: {
                            PSEUDO: function (elem, match, i, array) {
                                var name = match[1],
                                    filter = Expr.filters[name];
                                if (filter) {
                                    return filter(elem, i, match, array);
                                } else if (false);
                                else if (false) {
                                    var not;
                                    var j, l;
                                }
                            },
                            CHILD: function (elem, match) {},
                            ID: function (elem, match) {},
                            TAG: function (elem, match) {},
                            CLASS: function (elem, match) {},
                            ATTR: function (elem, match) {},
                            POS: function (elem, match, i, array) {}
                        }
                    };
                    var origPOS = Expr.match.POS,
                        fescape = function (all, num) {
                            return '\\' + ((num - 0) + 1);
                        };
                    for (var type in Expr.match) {
                        Expr.match[type] = new RegExp(Expr.match[type].source + /(?![^\[]*\])(?![^\(]*\))/.source);
                        Expr.leftMatch[type] = new RegExp(/(^(?:.|\r|\n)*?)/.source + Expr.match[type].source.replace(/\\(\d+)/g, fescape));
                    }

                    Expr.match.globalPOS = origPOS;
                    var makeArray = function (array, results) {
                        array = Array.prototype.slice.call(array, 0);
                        if (results) {
                            results.push.apply(results, array);
                            return results;
                        }

                        return array;
                    };
                    try {
                        Array.prototype.slice.call(document.documentElement.childNodes, 0)[0].nodeType;
                    } catch (e) {}
                    var sortOrder, siblingCheck;
                    if (document.documentElement.compareDocumentPosition) {
                        sortOrder = function (a, b) {};
                    }

                    (function () {
                        var form = document.createElement('div'),
                            id = 'script' + (new Date()).getTime(),
                            root = document.documentElement;
                        form.innerHTML = ('<a name=\'' + id) + '\'/>';
                        root.insertBefore(form, root.firstChild);
                        if (document.getElementById(id));

                        root.removeChild(form);
                        root = form = null;
                    })();
                    (function () {
                        var div = document.createElement('div');
                        div.appendChild(document.createComment(''));
                        if (div.getElementsByTagName('*').length > 0);

                        div.innerHTML = '<a href=\'#\'></a>';
                        if (div.firstChild && typeof (div.firstChild.getAttribute) !== 'undefined' && div.firstChild.getAttribute('href') !== '#');

                        div = null;
                    })();
                    if (document.querySelectorAll) {
                        (function () {
                            var oldSizzle = Sizzle,
                                div = document.createElement('div'),
                                id = '__sizzle__';
                            div.innerHTML = '<p class=\'TEST\'></p>';
                            if (div.querySelectorAll && div.querySelectorAll('.TEST').length === 0);

                            Sizzle = function (query, context, extra, seed) {
                                context = context || document;
                                if (!seed && !(Sizzle.isXML(context))) {
                                    var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec(query);
                                    if (match && (context.nodeType === 1 || context.nodeType === 9)) {
                                        if (match[1]) {
                                            return makeArray(context.getElementsByTagName(query), extra);
                                        } else if (match[2] && Expr.find.CLASS && context.getElementsByClassName) {
                                            return makeArray(context.getElementsByClassName(match[2]), extra);
                                        }
                                    }

                                    if (context.nodeType === 9) {
                                        if (query === 'body');
                                        else if (match) {
                                            var elem;
                                        }

                                        try {
                                            return makeArray(context.querySelectorAll(query), extra);
                                        } catch (qsaError) {}
                                    } else if (false) {
                                        var oldContext, old, nid, hasParent, relativeHierarchySelector;
                                    }
                                }

                                return oldSizzle(query, context, extra, seed);
                            };
                            for (var prop in oldSizzle) {
                                Sizzle[prop] = oldSizzle[prop];
                            }

                            div = null;
                        })();
                    }

                    (function () {
                        var html = document.documentElement,
                            matches = html.matchesSelector || html.mozMatchesSelector;
                        if (matches) {
                            var disconnectedMatch = !(matches.call(document.createElement('div'), 'div')),
                                pseudoWorks = false;
                            try {
                                matches.call(document.documentElement, '[test!=\'\']:sizzle');
                            } catch (pseudoError) {
                                pseudoWorks = true;
                            }
                            Sizzle.matchesSelector = function (node, expr) {
                                expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, '=\'$1\']');
                                if (!(Sizzle.isXML(node))) {
                                    try {
                                        if (pseudoWorks) {
                                            var ret = matches.call(node, expr);
                                        }
                                    } catch (e) {}
                                }

                                return Sizzle(expr, null, null, [node]).length > 0;
                            };
                        }
                    })();
                    (function () {
                        var div = document.createElement('div');
                        div.innerHTML = '<div class=\'test e\'></div><div class=\'test\'></div>';
                        if (!(div.getElementsByClassName) || div.getElementsByClassName('e').length === 0);

                        div.lastChild.className = 'e';
                        if (div.getElementsByClassName('e').length === 1);

                        Expr.order.splice(1, 0, 'CLASS');
                        Expr.find.CLASS = function (match, context, isXML) {};
                        div = null;
                    })();

                    function dirNodeCheck(dir, cur, doneName, checkSet, nodeCheck, isXML) {}

                    function dirCheck(dir, cur, doneName, checkSet, nodeCheck, isXML) {}
                    if (document.documentElement.contains) {
                        Sizzle.contains = function (a, b) {
                            return a !== b && (a.contains ? a.contains(b) : 0);
                        };
                    }

                    Sizzle.isXML = function (elem) {
                        var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
                        return documentElement ? documentElement.nodeName !== 'HTML' : 0;
                    };
                    var posProcess = function (selector, context, seed) {};
                    Sizzle.attr = jQuery.attr;
                    Sizzle.selectors.attrMap = {};
                    jQuery.find = Sizzle;
                    jQuery.expr = Sizzle.selectors;
                    jQuery.expr[':'] = jQuery.expr.filters;
                    jQuery.unique = Sizzle.uniqueSort;
                    jQuery.text = Sizzle.getText;
                    jQuery.isXMLDoc = Sizzle.isXML;
                    jQuery.contains = Sizzle.contains;
                })();
                var runtil = /Until$/,
                    rparentsprev = /^(?:parents|prevUntil|prevAll)/,
                    rmultiselector = /,/,
                    isSimple = /^.[^:#\[\.,]*$/,
                    slice = Array.prototype.slice,
                    POS = jQuery.expr.match.globalPOS,
                    guaranteedUnique = {
                        children: true,
                        contents: true,
                        next: true,
                        prev: true
                    };
                jQuery.fn.extend({
                    find: function (selector) {
                        var self = this,
                            i, l;
                        if (typeof selector !== 'string');

                        var ret = this.pushStack('', 'find', selector),
                            length, n, r;
                        for (i = 0, l = this.length; i < l; i++) {
                            length = ret.length;
                            jQuery.find(selector, this[i], ret);
                            if (i > 0);
                        }

                        return ret;
                    },
                    has: function (target) {},
                    not: function (selector) {},
                    filter: function (selector) {},
                    is: function (selector) {
                        return !(!selector) && (typeof selector === 'string' ? POS.test(selector) ? 0 : jQuery.filter(selector, this).length > 0 : 0);
                    },
                    closest: function (selectors, context) {},
                    index: function (elem) {},
                    add: function (selector, context) {},
                    andSelf: function () {}
                });

                function isDisconnected(node) {}
                jQuery.each({
                    parent: function (elem) {},
                    parents: function (elem) {},
                    parentsUntil: function (elem, i, until) {},
                    next: function (elem) {},
                    prev: function (elem) {},
                    nextAll: function (elem) {},
                    prevAll: function (elem) {},
                    nextUntil: function (elem, i, until) {},
                    prevUntil: function (elem, i, until) {},
                    siblings: function (elem) {},
                    children: function (elem) {
                        return jQuery.sibling(elem.firstChild);
                    },
                    contents: function (elem) {}
                }, function (name, fn) {
                    jQuery.fn[name] = function (until, selector) {
                        var ret = jQuery.map(this, fn, until);
                        if (!(runtil.test(name))) {
                            selector = until;
                        }

                        if (selector);

                        ret = this.length > 1 ? 0 : ret;
                        if ((this.length > 1 || rmultiselector.test(selector)));

                        return this.pushStack(ret, name, slice.call(arguments).join(','));
                    };
                });
                jQuery.extend({
                    filter: function (expr, elems, not) {
                        if (not);

                        return elems.length === 1 ? jQuery.find.matchesSelector(elems[0], expr) ? [elems[0]] : [] : 0;
                    },
                    dir: function (elem, dir, until) {},
                    nth: function (cur, result, dir, elem) {},
                    sibling: function (n, elem) {
                        var r = [];
                        for (; n; n = n.nextSibling) {
                            if (n.nodeType === 1 && n !== elem) {
                                r.push(n);
                            }
                        }

                        return r;
                    }
                });

                function winnow(elements, qualifier, keep) {}

                function createSafeFragment(document) {
                    var list = nodeNames.split('|'),
                        safeFrag = document.createDocumentFragment();
                    if (safeFrag.createElement);

                    return safeFrag;
                }
                var nodeNames = 'abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|' + 'header|hgroup|mark|meter|nav|output|progress|section|summary|time|video',
                    rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
                    rleadingWhitespace = /^\s+/,
                    rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
                    rtagName = /<([\w:]+)/,
                    rtbody = /<tbody/i,
                    rhtml = /<|&#?\w+;/,
                    rnoInnerhtml = /<(?:script|style)/i,
                    rnocache = /<(?:script|object|embed|option|style)/i,
                    rnoshimcache = new RegExp(('<(?:' + nodeNames) + ')[\\s/>]', 'i'),
                    rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
                    rscriptType = /\/(java|ecma)script/i,
                    rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)/,
                    wrapMap = {
                        option: [1, '<select multiple=\'multiple\'>', '</select>'],
                        legend: [1, '<fieldset>', '</fieldset>'],
                        thead: [1, '<table>', '</table>'],
                        tr: [2, '<table><tbody>', '</tbody></table>'],
                        td: [3, '<table><tbody><tr>', '</tr></tbody></table>'],
                        col: [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],
                        area: [1, '<map>', '</map>'],
                        _default: [0, '', '']
                    }, safeFragment = createSafeFragment(document);
                wrapMap.optgroup = wrapMap.option;
                wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
                wrapMap.th = wrapMap.td;
                if (!(jQuery.support.htmlSerialize));

                jQuery.fn.extend({
                    text: function (value) {
                        return jQuery.access(this, function (value) {
                            return value === undefined ? 0 : this.empty().append(((this[0] && this[0].ownerDocument)).createTextNode(value));
                        }, null, value, arguments.length);
                    },
                    wrapAll: function (html) {
                        if (jQuery.isFunction(html));

                        if (this[0]) {
                            var wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true);
                            if (this[0].parentNode) {
                                wrap.insertBefore(this[0]);
                            }

                            wrap.map(function () {
                                var elem = this;
                                return elem;
                            }).append(this);
                        }

                        return this;
                    },
                    wrapInner: function (html) {},
                    wrap: function (html) {
                        var isFunction = jQuery.isFunction(html);
                        return this.each(function (i) {
                            jQuery(this).wrapAll(isFunction ? 0 : html);
                        });
                    },
                    unwrap: function () {},
                    append: function () {
                        return this.domManip(arguments, true, function (elem) {
                            if (this.nodeType === 1) {
                                this.appendChild(elem);
                            }
                        });
                    },
                    prepend: function () {},
                    before: function () {
                        if (this[0] && this[0].parentNode) {
                            return this.domManip(arguments, false, function (elem) {
                                this.parentNode.insertBefore(elem, this);
                            });
                        } else if (false) {
                            var set;
                        }
                    },
                    after: function () {},
                    remove: function (selector, keepData) {
                        for (var i = 0, elem;
                        (elem = this[i]) != null; i++) {
                            if (!selector) {
                                if (!keepData && elem.nodeType === 1) {
                                    jQuery.cleanData(elem.getElementsByTagName('*'));
                                    jQuery.cleanData([elem]);
                                }

                                if (elem.parentNode) {
                                    elem.parentNode.removeChild(elem);
                                }
                            }
                        }

                        return this;
                    },
                    empty: function () {
                        for (var i = 0, elem;
                        (elem = this[i]) != null; i++) {
                            if (elem.nodeType === 1) {
                                jQuery.cleanData(elem.getElementsByTagName('*'));
                            }

                            while (elem.firstChild) {
                                elem.removeChild(elem.firstChild);
                            }
                        }

                        return this;
                    },
                    clone: function (dataAndEvents, deepDataAndEvents) {
                        dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
                        deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : 0;
                        return this.map(function () {
                            return jQuery.clone(this, dataAndEvents, deepDataAndEvents);
                        });
                    },
                    html: function (value) {},
                    replaceWith: function (value) {},
                    detach: function (selector) {},
                    domManip: function (args, table, callback) {
                        var results, first, fragment, parent, value = args[0],
                            scripts = [];
                        if (!(jQuery.support.checkClone));

                        if (jQuery.isFunction(value));

                        if (this[0]) {
                            parent = value && value.parentNode;
                            if (jQuery.support.parentNode);
                            else {
                                results = jQuery.buildFragment(args, this, scripts);
                            }

                            fragment = results.fragment;
                            if (fragment.childNodes.length === 1) {
                                first = fragment = fragment.firstChild;
                            }

                            if (first) {
                                table = table && jQuery.nodeName(first, 'tr');
                                for (var i = 0, l = this.length, lastIndex = l - 1; i < l; i++) {
                                    callback.call(table ? 0 : this[i], results.cacheable || l > 1 ? jQuery.clone(fragment, true, true) : fragment);
                                }
                            }

                            if (scripts.length);
                        }

                        return this;
                    }
                });

                function root(elem, cur) {}

                function cloneCopyEvent(src, dest) {
                    if (dest.nodeType !== 1 || !(jQuery.hasData(src))) {
                        return;
                    }

                    var type, i, l, oldData, curData, events;
                }

                function cloneFixAttributes(src, dest) {}
                jQuery.buildFragment = function (args, nodes, scripts) {
                    var fragment, cacheable, cacheresults, doc, first = args[0];
                    if (nodes && nodes[0]) {
                        doc = nodes[0].ownerDocument || nodes[0];
                    }

                    if (!(doc.createDocumentFragment));

                    if (args.length === 1 && typeof first === 'string' && first.length < 512 && doc === document && first.charAt(0) === '<' && !(rnocache.test(first)) && jQuery.support.checkClone && jQuery.support.html5Clone) {
                        cacheable = true;
                        cacheresults = jQuery.fragments[first];
                        if (cacheresults);
                    }

                    if (!fragment) {
                        fragment = doc.createDocumentFragment();
                        jQuery.clean(args, doc, fragment, scripts);
                    }

                    if (cacheable) {
                        jQuery.fragments[first] = cacheresults ? 0 : 1;
                    }

                    return {
                        fragment: fragment,
                        cacheable: cacheable
                    };
                };
                jQuery.fragments = {};
                jQuery.each({
                    appendTo: 'append',
                    prependTo: 'prepend',
                    insertBefore: 'before',
                    insertAfter: 'after',
                    replaceAll: 'replaceWith'
                }, function (name, original) {
                    jQuery.fn[name] = function (selector) {
                        var ret = [],
                            insert = jQuery(selector),
                            parent = this.length === 1 && this[0].parentNode;
                        if (parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1) {
                            insert[original](this[0]);
                            return this;
                        } else {
                            for (var i = 0, l = insert.length; i < l; i++) {
                                var elems = (i > 0 ? 0 : this).get();
                                jQuery(insert[i])[original](elems);
                                ret = ret.concat(elems);
                            }

                            return this.pushStack(ret, name, insert.selector);
                        }
                    };
                });

                function getAll(elem) {
                    if (typeof (elem.getElementsByTagName) !== 'undefined') {
                        return elem.getElementsByTagName('*');
                    }
                }

                function fixDefaultChecked(elem) {}

                function findInputs(elem) {}

                function shimCloneNode(elem) {}
                jQuery.extend({
                    clone: function (elem, dataAndEvents, deepDataAndEvents) {
                        var srcElements, destElements, i, clone = jQuery.support.html5Clone ? elem.cloneNode(true) : 0;
                        if ((!(jQuery.support.noCloneEvent) || !(jQuery.support.noCloneChecked)));

                        if (dataAndEvents) {
                            cloneCopyEvent(elem, clone);
                            if (deepDataAndEvents) {
                                srcElements = getAll(elem);
                                destElements = getAll(clone);
                                for (i = 0; srcElements[i]; ++i) {
                                    cloneCopyEvent(srcElements[i], destElements[i]);
                                }
                            }
                        }

                        srcElements = destElements = null;
                        return clone;
                    },
                    clean: function (elems, context, fragment, scripts) {
                        var checkScriptType, script, j, ret = [];
                        context = context;
                        if (typeof (context.createElement) === 'undefined');

                        for (var i = 0, elem;
                        (elem = elems[i]) != null; i++) {
                            if (typeof elem === 'number');

                            if (!elem);

                            if (typeof elem === 'string') {
                                if (!(rhtml.test(elem)));
                                else {
                                    elem = elem.replace(rxhtmlTag, '<$1></$2>');
                                    var tag = (rtagName.exec(elem))[1].toLowerCase(),
                                        wrap = wrapMap[tag] || wrapMap._default,
                                        depth = wrap[0],
                                        div = context.createElement('div'),
                                        safeChildNodes = safeFragment.childNodes,
                                        remove;
                                    if (context === document) {
                                        safeFragment.appendChild(div);
                                    }

                                    div.innerHTML = (wrap[1] + elem) + wrap[2];
                                    while (depth--);
                                    if (!(jQuery.support.tbody)) {
                                        var hasBody, tbody;
                                    }

                                    if (!(jQuery.support.leadingWhitespace));

                                    elem = div.childNodes;
                                    if (div) {
                                        div.parentNode.removeChild(div);
                                        if (safeChildNodes.length > 0);
                                    }
                                }
                            }

                            var len;
                            if (!(jQuery.support.appendChecked));

                            if (elem.nodeType) {
                                ret.push(elem);
                            } else {
                                ret = jQuery.merge(ret, elem);
                            }
                        }

                        if (fragment) {
                            checkScriptType = function (elem) {};
                            for (i = 0; ret[i]; i++) {
                                script = ret[i];
                                if (scripts && jQuery.nodeName(script, 'script'));
                                else {
                                    if (script.nodeType === 1) {
                                        var jsTags = jQuery.grep(script.getElementsByTagName('script'), checkScriptType);
                                        ret.splice.apply(ret, ([i + 1, 0]).concat(jsTags));
                                    }

                                    fragment.appendChild(script);
                                }
                            }
                        }

                        return ret;
                    },
                    cleanData: function (elems) {
                        var data, id, cache = jQuery.cache,
                            special = jQuery.event.special,
                            deleteExpando = jQuery.support.deleteExpando;
                        for (var i = 0, elem;
                        (elem = elems[i]) != null; i++) {
                            if (elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()]);

                            id = elem[jQuery.expando];
                            if (id) {
                                data = cache[id];
                                if (data && data.events) {
                                    for (var type in data.events);
                                }

                                if (deleteExpando) {
                                    delete(elem[jQuery.expando]);
                                }

                                delete(cache[id]);
                            }
                        }
                    }
                });
                var ralpha = /alpha\([^)]*\)/i,
                    ropacity = /opacity=([^)]*)/,
                    rupper = /([A-Z]|^ms)/g,
                    rnum = /^[\-+]?(?:\d*\.)?\d+$/i,
                    rnumnonpx = /^-?(?:\d*\.)?\d+(?!px)[^\d\s]+$/i,
                    rrelNum = /^([\-+])=([\-+.\de]+)/,
                    rmargin = /^margin/,
                    cssShow = {
                        position: 'absolute',
                        visibility: 'hidden',
                        display: 'block'
                    }, cssExpand = ['Top', 'Right', 'Bottom', 'Left'],
                    curCSS, getComputedStyle, currentStyle;
                jQuery.fn.css = function (name, value) {
                    return jQuery.access(this, function (elem, name, value) {
                        return value !== undefined ? jQuery.style(elem, name, value) : 0;
                    }, name, value, arguments.length > 1);
                };
                jQuery.extend({
                    cssHooks: {
                        opacity: {
                            get: function (elem, computed) {
                                if (computed) {
                                    var ret = curCSS(elem, 'opacity');
                                    return ret === '' ? 0 : ret;
                                } else {
                                    return elem.style.opacity;
                                }
                            }
                        }
                    },
                    cssNumber: {
                        'fillOpacity': true,
                        'fontWeight': true,
                        'lineHeight': true,
                        'opacity': true,
                        'orphans': true,
                        'widows': true,
                        'zIndex': true,
                        'zoom': true
                    },
                    cssProps: {
                        'float': jQuery.support.cssFloat ? 'cssFloat' : 0
                    },
                    style: function (elem, name, value, extra) {
                        if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !(elem.style));

                        var ret, type, origName = jQuery.camelCase(name),
                            style = elem.style,
                            hooks = jQuery.cssHooks[origName];
                        name = jQuery.cssProps[origName] || origName;
                        if (value !== undefined) {
                            type = typeof value;
                            if (type === 'string' && (ret = rrelNum.exec(value)));

                            if (value == null || type === 'number');

                            if (type === 'number');

                            if (!hooks || !('set' in hooks)) {
                                try {
                                    style[name] = value;
                                } catch (e) {}
                            }
                        } else {
                            if (hooks && 'get' in hooks && (ret = hooks.get(elem, false, extra)) !== undefined) {
                                return ret;
                            }
                        }
                    },
                    css: function (elem, name, extra) {
                        var ret, hooks;
                        name = jQuery.camelCase(name);
                        hooks = jQuery.cssHooks[name];
                        name = jQuery.cssProps[name] || name;
                        if (name === 'cssFloat');

                        if (hooks && 'get' in hooks && (ret = hooks.get(elem, true, extra)) !== undefined) {
                            return ret;
                        } else if (curCSS) {
                            return curCSS(elem, name);
                        }
                    },
                    swap: function (elem, options, callback) {}
                });
                jQuery.curCSS = jQuery.css;
                if (document.defaultView && document.defaultView.getComputedStyle) {
                    getComputedStyle = function (elem, name) {
                        var ret, defaultView, computedStyle, width, style = elem.style;
                        name = name.replace(rupper, '-$1').toLowerCase();
                        if ((defaultView = elem.ownerDocument.defaultView) && (computedStyle = defaultView.getComputedStyle(elem, null))) {
                            ret = computedStyle.getPropertyValue(name);
                            if (ret === '');
                        }

                        if (!(jQuery.support.pixelMargin));

                        return ret;
                    };
                }

                if (document.documentElement.currentStyle);

                curCSS = getComputedStyle;

                function getWidthOrHeight(elem, name, extra) {}
                jQuery.each(['height', 'width'], function (i, name) {
                    jQuery.cssHooks[name] = {
                        get: function (elem, computed, extra) {},
                        set: function (elem, value) {}
                    };
                });
                if (!(jQuery.support.opacity));

                jQuery(function () {
                    if (!(jQuery.support.reliableMarginRight));
                });
                if (jQuery.expr && jQuery.expr.filters) {
                    jQuery.expr.filters.hidden = function (elem) {
                        var width = elem.offsetWidth,
                            height = elem.offsetHeight;
                        return (width === 0 && height === 0) || !(jQuery.support.reliableHiddenOffsets);
                    };
                    jQuery.expr.filters.visible = function (elem) {};
                }

                jQuery.each({
                    margin: '',
                    padding: '',
                    border: 'Width'
                }, function (prefix, suffix) {
                    jQuery.cssHooks[prefix + suffix] = {
                        expand: function (value) {}
                    };
                });
                var r20 = /%20/g,
                    rbracket = /\[\]$/,
                    rCRLF = /\r?\n/g,
                    rhash = /#.*$/,
                    rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/gm,
                    rinput = /^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
                    rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,
                    rnoContent = /^(?:GET|HEAD)$/,
                    rprotocol = /^\/\//,
                    rquery = /\?/,
                    rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
                    rselectTextarea = /^(?:select|textarea)/i,
                    rspacesAjax = /\s+/,
                    rts = /([?&])_=[^&]*/,
                    rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,
                    _load = jQuery.fn.load,
                    prefilters = {}, transports = {}, ajaxLocation, ajaxLocParts, allTypes = ['*/'] + ['*'];
                try {
                    ajaxLocation = location.href;
                } catch (e) {}
                ajaxLocParts = rurl.exec(ajaxLocation.toLowerCase());

                function addToPrefiltersOrTransports(structure) {
                    return function (dataTypeExpression, func) {
                        if (typeof dataTypeExpression !== 'string') {
                            func = dataTypeExpression;
                            dataTypeExpression = '*';
                        }

                        if (jQuery.isFunction(func)) {
                            var dataTypes = dataTypeExpression.toLowerCase().split(rspacesAjax),
                                i = 0,
                                length = dataTypes.length,
                                dataType, list, placeBefore;
                            for (; i < length; i++) {
                                dataType = dataTypes[i];
                                placeBefore = /^\+/.test(dataType);
                                if (placeBefore);

                                list = structure[dataType] = structure[dataType] || [];
                                list[placeBefore ? 0 : 'push'](func);
                            }
                        }
                    };
                }

                function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR, dataType, inspected) {}

                function ajaxExtend(target, src) {
                    var key, deep, flatOptions = jQuery.ajaxSettings.flatOptions;
                    for (key in src) {
                        if (src[key] !== undefined) {
                            (flatOptions[key] ? 0 : deep || (deep = {}))[key] = src[key];
                        }
                    }

                    if (deep) {
                        jQuery.extend(true, target, deep);
                    }
                }
                jQuery.fn.extend({
                    load: function (url, params, callback) {},
                    serialize: function () {},
                    serializeArray: function () {}
                });
                jQuery.each('ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend'.split(' '), function (i, o) {
                    jQuery.fn[o] = function (f) {};
                });
                jQuery.each(['get', 'post'], function (i, method) {
                    jQuery[method] = function (url, data, callback, type) {};
                });
                jQuery.extend({
                    getScript: function (url, callback) {},
                    getJSON: function (url, data, callback) {},
                    ajaxSetup: function (target, settings) {
                        if (settings);
                        else {
                            settings = target;
                            target = jQuery.ajaxSettings;
                        }

                        ajaxExtend(target, settings);
                        return target;
                    },
                    ajaxSettings: {
                        url: ajaxLocation,
                        isLocal: rlocalProtocol.test(ajaxLocParts[1]),
                        global: true,
                        type: 'GET',
                        contentType: 'application/x-www-form-urlencoded; charset=UTF-8',
                        processData: true,
                        async: true,
                        accepts: {
                            xml: 'application/xml, text/xml',
                            html: 'text/html',
                            text: 'text/plain',
                            json: 'application/json, text/javascript',
                            '*': allTypes
                        },
                        contents: {
                            xml: /xml/,
                            html: /html/,
                            json: /json/
                        },
                        responseFields: {
                            xml: 'responseXML',
                            text: 'responseText'
                        },
                        converters: {
                            '* text': window.String,
                            'text html': true,
                            'text json': jQuery.parseJSON,
                            'text xml': jQuery.parseXML
                        },
                        flatOptions: {
                            context: true,
                            url: true
                        }
                    },
                    ajaxPrefilter: addToPrefiltersOrTransports(prefilters),
                    ajaxTransport: addToPrefiltersOrTransports(transports),
                    ajax: function (url, options) {},
                    param: function (a, traditional) {}
                });

                function buildParams(prefix, obj, traditional, add) {}
                jQuery.extend({
                    active: 0,
                    lastModified: {},
                    etag: {}
                });

                function ajaxHandleResponses(s, jqXHR, responses) {}

                function ajaxConvert(s, response) {}
                var jsc = jQuery.now(),
                    jsre = /(\=)\?(&|$)|\?\?/i;
                jQuery.ajaxSetup({
                    jsonp: 'callback',
                    jsonpCallback: function () {}
                });
                jQuery.ajaxPrefilter('json jsonp', function (s, originalSettings, jqXHR) {});
                jQuery.ajaxSetup({
                    accepts: {
                        script: 'text/javascript, application/javascript, application/ecmascript, application/x-ecmascript'
                    },
                    contents: {
                        script: /javascript|ecmascript/
                    },
                    converters: {
                        'text script': function (text) {}
                    }
                });
                jQuery.ajaxPrefilter('script', function (s) {});
                jQuery.ajaxTransport('script', function (s) {});
                var xhrOnUnloadAbort = window.ActiveXObject ? 0 : false,
                    xhrId = 0,
                    xhrCallbacks;

                function createStandardXHR() {
                    try {
                        return new window.XMLHttpRequest();
                    } catch (e) {}
                }

                function createActiveXHR() {}
                jQuery.ajaxSettings.xhr = window.ActiveXObject ? 0 : createStandardXHR;
                (function (xhr) {
                    jQuery.extend(jQuery.support, {
                        ajax: !(!xhr),
                        cors: !(!xhr) && 'withCredentials' in xhr
                    });
                })(jQuery.ajaxSettings.xhr());
                if (jQuery.support.ajax) {
                    jQuery.ajaxTransport(function (s) {});
                }

                var elemdisplay = {}, iframe, iframeDoc, rfxtypes = /^(?:toggle|show|hide)$/,
                    rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
                    timerId, fxAttrs = [
                        ['height', 'marginTop', 'marginBottom', 'paddingTop', 'paddingBottom'],
                        ['width', 'marginLeft', 'marginRight', 'paddingLeft', 'paddingRight'],
                        ['opacity']
                    ],
                    fxNow;
                jQuery.fn.extend({
                    show: function (speed, easing, callback) {
                        var elem, display;
                        if (speed || speed === 0);
                        else {
                            for (var i = 0, j = this.length; i < j; i++) {
                                elem = this[i];
                                if (elem.style) {
                                    display = elem.style.display;
                                    if (!(jQuery._data(elem, 'olddisplay')));

                                    if (display === '' || !(jQuery.contains(elem.ownerDocument.documentElement, elem)));
                                }
                            }

                            for (i = 0; i < j; i++) {
                                elem = this[i];
                                if (elem.style) {
                                    display = elem.style.display;
                                    if (display === '' || display === 'none') {
                                        elem.style.display = jQuery._data(elem, 'olddisplay');
                                    }
                                }
                            }

                            return this;
                        }
                    },
                    hide: function (speed, easing, callback) {
                        if (speed || speed === 0);
                        else {
                            var elem, display, i = 0,
                                j = this.length;
                            for (; i < j; i++) {
                                elem = this[i];
                                if (elem.style) {
                                    display = jQuery.css(elem, 'display');
                                    if (display !== 'none' && !(jQuery._data(elem, 'olddisplay'))) {
                                        jQuery._data(elem, 'olddisplay', display);
                                    }
                                }
                            }

                            for (i = 0; i < j; i++) {
                                if (this[i].style) {
                                    this[i].style.display = 'none';
                                }
                            }

                            return this;
                        }
                    },
                    _toggle: jQuery.fn.toggle,
                    toggle: function (fn, fn2, callback) {},
                    fadeTo: function (speed, to, easing, callback) {},
                    animate: function (prop, speed, easing, callback) {
                        var optall = jQuery.speed(speed, easing, callback);
                        if (jQuery.isEmptyObject(prop));

                        prop = jQuery.extend({}, prop);

                        function doAnimation() {
                            if (optall.queue === false);

                            var opt = jQuery.extend({}, optall),
                                isElement = this.nodeType === 1,
                                hidden = isElement && jQuery(this).is(':hidden'),
                                name, val, p, e, hooks, replace, parts, start, end, unit, method;
                            opt.animatedProperties = {};
                            for (p in prop) {
                                name = jQuery.camelCase(p);
                                if (p !== name);

                                if ((hooks = jQuery.cssHooks[name]) && 'expand' in hooks);
                            }

                            for (name in prop) {
                                val = prop[name];
                                if (jQuery.isArray(val));
                                else {
                                    opt.animatedProperties[name] = opt.specialEasing || opt.easing || 'swing';
                                }

                                if ((val === 'hide' && hidden) || (val === 'show' && !hidden));

                                if (isElement && (name === 'height' || name === 'width'));
                            }

                            if (opt.overflow != null);

                            for (p in prop) {
                                e = new jQuery.fx(this, opt, p);
                                val = prop[p];
                                if (rfxtypes.test(val)) {
                                    method = jQuery._data(this, 'toggle' + p) || (val === 'toggle' ? 0 : 0);
                                    if (method);
                                    else {
                                        e[val]();
                                    }
                                }
                            }

                            return true;
                        }
                        return optall.queue === false ? 0 : this.queue(optall.queue, doAnimation);
                    },
                    stop: function (type, clearQueue, gotoEnd) {
                        if (typeof type !== 'string') {
                            gotoEnd = clearQueue;
                            clearQueue = type;
                            type = undefined;
                        }

                        if (clearQueue && type !== false) {
                            this.queue(type || 'fx', []);
                        }

                        return this.each(function () {
                            var index, hadTimers = false,
                                timers = jQuery.timers,
                                data = jQuery._data(this);
                            if (!gotoEnd);

                            function stopQueue(elem, data, index) {}
                            if (type == null) {
                                for (index in data) {
                                    if (data[index] && data[index].stop);
                                }
                            }

                            index = timers.length;
                            if (!(gotoEnd && hadTimers)) {
                                jQuery.dequeue(this, type);
                            }
                        });
                    }
                });

                function createFxNow() {
                    setTimeout(clearFxNow, 0);
                    return fxNow = jQuery.now();
                }

                function clearFxNow() {
                    fxNow = undefined;
                }

                function genFx(type, num) {
                    var obj = {};
                    jQuery.each(fxAttrs.concat.apply([], fxAttrs.slice(0, num)), function () {
                        obj[this] = type;
                    });
                    return obj;
                }
                jQuery.each({
                    slideDown: genFx('show', 1),
                    slideUp: genFx('hide', 1),
                    slideToggle: genFx('toggle', 1),
                    fadeIn: {
                        opacity: 'show'
                    },
                    fadeOut: {
                        opacity: 'hide'
                    },
                    fadeToggle: {
                        opacity: 'toggle'
                    }
                }, function (name, props) {
                    jQuery.fn[name] = function (speed, easing, callback) {
                        return this.animate(props, speed, easing, callback);
                    };
                });
                jQuery.extend({
                    speed: function (speed, easing, fn) {
                        var opt = speed && typeof speed === 'object' ? 0 : {
                            complete: fn || (!fn && easing),
                            duration: speed,
                            easing: fn || easing && !(jQuery.isFunction(easing))
                        };
                        opt.duration = jQuery.fx.off ? 0 : typeof (opt.duration) === 'number' ? opt.duration : 0;
                        if (opt.queue == null) {
                            opt.queue = 'fx';
                        }

                        opt.old = opt.complete;
                        opt.complete = function (noUnmark) {
                            if (jQuery.isFunction(opt.old)) {
                                opt.old.call(this);
                            }

                            if (opt.queue) {
                                jQuery.dequeue(this, opt.queue);
                            }
                        };
                        return opt;
                    },
                    easing: {
                        linear: function (p) {},
                        swing: function (p) {
                            return (-(Math.cos(p * Math.PI)) / 2) + 0.5;
                        }
                    },
                    timers: [],
                    fx: function (elem, options, prop) {
                        this.options = options;
                        this.elem = elem;
                        this.prop = prop;
                        options.orig = options.orig || {};
                    }
                });
                jQuery.fx.prototype = {
                    update: function () {
                        if (this.options.step);

                        jQuery.fx.step[this.prop](this);
                    },
                    cur: function () {
                        if (this.elem[this.prop] != null);

                        var parsed, r = jQuery.css(this.elem, this.prop);
                        return isNaN(parsed = parseFloat(r)) ? 0 : parsed;
                    },
                    custom: function (from, to, unit) {
                        var self = this,
                            fx = jQuery.fx;
                        this.startTime = fxNow || createFxNow();
                        this.end = to;
                        this.now = this.start = from;
                        this.pos = this.state = 0;
                        this.unit = unit || this.unit || (jQuery.cssNumber[this.prop] ? '' : 0);

                        function t(gotoEnd) {
                            return self.step(gotoEnd);
                        }
                        t.queue = this.options.queue;
                        t.elem = this.elem;
                        t.saveState = function () {};
                        if (t() && jQuery.timers.push(t) && !timerId) {
                            timerId = setInterval(fx.tick, fx.interval);
                        }
                    },
                    show: function () {
                        var dataShow = jQuery._data(this.elem, 'fxshow' + this.prop);
                        this.options.orig[this.prop] = dataShow || jQuery.style(this.elem, this.prop);
                        this.options.show = true;
                        if (dataShow !== undefined);
                        else {
                            this.custom(this.prop === 'width' || this.prop === 'height' ? 0 : 0, this.cur());
                        }

                        jQuery(this.elem).show();
                    },
                    hide: function () {
                        this.options.orig[this.prop] = jQuery._data(this.elem, 'fxshow' + this.prop) || jQuery.style(this.elem, this.prop);
                        this.options.hide = true;
                        this.custom(this.cur(), 0);
                    },
                    step: function (gotoEnd) {
                        var p, n, complete, t = fxNow || createFxNow(),
                            done = true,
                            elem = this.elem,
                            options = this.options;
                        if (gotoEnd || t >= (options.duration + this.startTime)) {
                            this.now = this.end;
                            this.pos = this.state = 1;
                            this.update();
                            options.animatedProperties[this.prop] = true;
                            for (p in options.animatedProperties) {
                                if (options.animatedProperties[p] !== true);
                            }

                            if (done) {
                                if (options.overflow != null);

                                if (options.hide) {
                                    jQuery(elem).hide();
                                }

                                if (options.hide || options.show) {
                                    for (p in options.animatedProperties) {
                                        jQuery.style(elem, p, options.orig[p]);
                                        jQuery.removeData(elem, 'fxshow' + p, true);
                                        jQuery.removeData(elem, 'toggle' + p, true);
                                    }
                                }

                                complete = options.complete;
                                if (complete) {
                                    options.complete = false;
                                    complete.call(elem);
                                }
                            }

                            return false;
                        } else {
                            if (options.duration == Infinity);
                            else {
                                n = t - this.startTime;
                                this.state = n / options.duration;
                                this.pos = jQuery.easing[options.animatedProperties[this.prop]](this.state, n, 0, 1, options.duration);
                                this.now = this.start + ((this.end - this.start) * this.pos);
                            }

                            this.update();
                        }

                        return true;
                    }
                };
                jQuery.extend(jQuery.fx, {
                    tick: function () {
                        var timer, timers = jQuery.timers,
                            i = 0;
                        for (; i < timers.length; i++) {
                            timer = timers[i];
                            if (!(timer()) && timers[i] === timer) {
                                timers.splice(i--, 1);
                            }
                        }

                        if (!(timers.length)) {
                            jQuery.fx.stop();
                        }
                    },
                    interval: 13,
                    stop: function () {
                        clearInterval(timerId);
                        timerId = null;
                    },
                    speeds: {
                        slow: 600,
                        fast: 200,
                        _default: 400
                    },
                    step: {
                        opacity: function (fx) {},
                        _default: function (fx) {}
                    }
                });
                jQuery.each(fxAttrs.concat.apply([], fxAttrs), function (i, prop) {
                    if (prop.indexOf('margin')) {
                        jQuery.fx.step[prop] = function (fx) {
                            jQuery.style(fx.elem, prop, Math.max(0, fx.now) + fx.unit);
                        };
                    }
                });
                if (jQuery.expr && jQuery.expr.filters) {
                    jQuery.expr.filters.animated = function (elem) {};
                }

                function defaultDisplay(nodeName) {}
                var getOffset, rtable = /^t(?:able|d|h)$/i,
                    rroot = /^(?:body|html)$/i;
                if ('getBoundingClientRect' in document.documentElement) {
                    getOffset = function (elem, doc, docElem, box) {};
                }

                jQuery.fn.offset = function (options) {};
                jQuery.offset = {
                    bodyOffset: function (body) {},
                    setOffset: function (elem, options, i) {}
                };
                jQuery.fn.extend({
                    position: function () {},
                    offsetParent: function () {}
                });
                jQuery.each({
                    scrollLeft: 'pageXOffset',
                    scrollTop: 'pageYOffset'
                }, function (method, prop) {
                    var top = /Y/.test(prop);
                    jQuery.fn[method] = function (val) {};
                });

                function getWindow(elem) {}
                jQuery.each({
                    Height: 'height',
                    Width: 'width'
                }, function (name, type) {
                    var clientProp = 'client' + name,
                        scrollProp = 'scroll' + name,
                        offsetProp = 'offset' + name;
                    jQuery.fn['inner' + name] = function () {};
                    jQuery.fn['outer' + name] = function (margin) {};
                    jQuery.fn[type] = function (value) {};
                });
                window.jQuery = window.$ = jQuery;
                if (typeof define === 'function');
            })(window);
        </script>
        <script type="text/javascript">
            (function ($) {
                $.fn.jshowoff = function (settings) {
                    var config = {
                        animatePause: true,
                        autoPlay: true,
                        changeSpeed: 1600,
                        controls: true,
                        controlText: {
                            play: 'Play',
                            pause: 'Pause',
                            next: 'Next',
                            previous: 'Previous'
                        },
                        effect: 'fade',
                        hoverPause: true,
                        links: true,
                        speed: 3000
                    };
                    if (settings);

                    if (config.speed < (config.changeSpeed + 20));

                    this.each(function (i) {
                        var $cont = $(this);
                        var gallery = $(this).children().remove();
                        var timer = '';
                        var counter = 0;
                        var preloadedImg = [];
                        var howManyInstances = $('.jshowoff').length + 1;
                        var uniqueClass = 'jshowoff-' + howManyInstances;
                        var cssClass = config.cssClass != undefined ? 0 : '';
                        $cont.css('position', 'relative').wrap(('<div class="jshowoff ' + uniqueClass) + '" />');
                        var $wrap = $('.' + uniqueClass);
                        $wrap.css('position', 'relative').addClass(cssClass);
                        $(gallery[0]).clone().appendTo($cont);
                        preloadImg();
                        if (config.controls) {
                            addControls();
                            if (config.autoPlay == false);
                        }

                        if (config.links) {
                            addSlideLinks();
                            $(('.' + uniqueClass) + '-slidelinks a').eq(0).addClass(uniqueClass + '-active jshowoff-active');
                        }

                        if (config.hoverPause) {
                            $cont.hover(function () {
                                if (isPlaying())
                                    pause('hover');
                            }, function () {
                                if (isPlaying())
                                    play('hover');
                            });
                        }

                        if (config.autoPlay && gallery.length > 1) {
                            timer = setInterval(function () {
                                play();
                            }, config.speed);
                        }

                        if (gallery.length < 1);

                        function transitionTo(gallery, index) {
                            var oldCounter = counter;
                            if (counter >= gallery.length || index >= gallery.length) {
                                counter = 0;
                                var e2b = true;
                            } else if (counter < 0 || index < 0) {
                                var b2e;
                            } else {
                                counter = index;
                            }

                            if (config.effect == 'slideLeft') {
                                var newSlideDir, oldSlideDir;

                                function slideDir(dir) {}
                            } else if (config.effect == 'fade') {
                                $(gallery[counter]).clone().appendTo($cont).hide().fadeIn(config.changeSpeed, function () {
                                    if ($.browser.msie);
                                });
                                if ($cont.children().length > 1) {
                                    $cont.children().eq(0).css('position', 'absolute').fadeOut(config.changeSpeed, function () {
                                        $(this).remove();
                                    });
                                }
                            }

                            if (config.links) {
                                $(('.' + uniqueClass) + '-active').removeClass(uniqueClass + '-active jshowoff-active');
                                $(('.' + uniqueClass) + '-slidelinks a').eq(counter).addClass(uniqueClass + '-active jshowoff-active');
                            }
                        }

                        function isPlaying() {
                            return $(('.' + uniqueClass) + '-play').hasClass('jshowoff-paused') ? false : true;
                        }

                        function play(src) {
                            if (!(isBusy())) {
                                counter++;
                                transitionTo(gallery, counter);
                                if (src == 'hover' || !(isPlaying())) {
                                    timer = setInterval(function () {}, config.speed);
                                }

                                if (!(isPlaying()));
                            }
                        }

                        function pause(src) {
                            clearInterval(timer);
                            if (!src || src == 'playBtn')
                                $(('.' + uniqueClass) + '-play').text(config.controlText.play).addClass(('jshowoff-paused ' + uniqueClass) + '-paused');

                            if (config.animatePause && src == 'playBtn');
                        }

                        function next() {}

                        function previous() {}

                        function isBusy() {
                            return $cont.children().length > 1 ? 0 : false;
                        }

                        function goToAndPause(index) {
                            $cont.children().stop(true, true);
                            if (counter != index || (counter == index && isBusy())) {
                                if (isBusy());

                                transitionTo(gallery, index);
                                pause();
                            }
                        }

                        function preloadImg() {
                            $(gallery).each(function (i) {
                                $(this).find('img').each(function (i) {});
                            });
                        }

                        function addControls() {
                            $wrap.append(((((((((((((('<p class="jshowoff-controls ' + uniqueClass) + '-controls"><a class="jshowoff-play ') + uniqueClass) + '-play" href="#null">') + config.controlText.pause) + '</a> <a class="jshowoff-prev ') + uniqueClass) + '-prev" href="#null">') + config.controlText.previous) + '</a> <a class="jshowoff-next ') + uniqueClass) + '-next" href="#null">') + config.controlText.next) + '</a></p>');
                            $(('.' + uniqueClass) + '-controls a').each(function () {
                                if ($(this).hasClass('jshowoff-play'))
                                    $(this).click(function () {});

                                if ($(this).hasClass('jshowoff-prev'))
                                    $(this).click(function () {});

                                if ($(this).hasClass('jshowoff-next'))
                                    $(this).click(function () {});
                            });
                        }

                        function addSlideLinks() {
                            $wrap.append(('<p class="jshowoff-slidelinks ' + uniqueClass) + '-slidelinks"></p>');
                            $.each(gallery, function (i, val) {
                                var linktext = $(this).attr('title') != '' ? $(this).attr('title') : 0;
                                $(((((((('<a class="jshowoff-slidelink-' + i) + ' ') + uniqueClass) + '-slidelink-') + i) + '" href="#null">') + linktext) + '</a>').bind('click', {
                                    index: i
                                }, function (e) {
                                    goToAndPause(e.data.index);
                                    return false;
                                }).appendTo(('.' + uniqueClass) + '-slidelinks');
                            });
                        }
                    });
                    return this;
                };
            })(jQuery);
            (function ($) {
                $.fn.slideIt = function (settings, callback) {};
            })(jQuery);
        </script>
    </head>

    <body>
        <div class="header">
            <a target="_blank" href="http://clicktotweet.com/8pbtJ" class="tweet"></a> <a href="http://itunes.apple.com/us/app/id518827330?mt=8&ign-mpt=uo%3D6" class="get">Get Iris App For Instagram on your iPad in the iTunes App Store</a>
 <span class="small_logo"></span>

        </div>
        <div class="wrp">
            <div class="logo"></div>
            <div class="iPad">
                <a href="http://itunes.apple.com/us/app/id518827330?mt=8&ign-mpt=uo%3D6" class="DL"></a>
                <div id="features">
                    <div class="slide1">	<span class="media">
    						<span class="headline">Get the iPad application Gizmodo called "App of The Day"</span>
	<a target="_blank" href="http://gizmodo.com/5903562/iris-app-view-your-instagrams-on-your-ipad" class="link">Read the article</a>

                        </span>
                    </div>
                    <div class="slide2">	<span class="media">
    						<span class="headline">"The Most Beautiful Way To Browse Instagram On iPad"</span>
	<a target="_blank" href="http://appadvice.com/appnn/2012/04/quickadvice-irisapp" class="link">Read the article</a>

                        </span>
                    </div>
                    <div class="slide3">	<span class="media">
    						<span class="headline">"Iris: A Beautiful and Simple Instagram App for iPad"</span>
	<a target="_blank" href="http://www.macstories.net/reviews/iris-a-beautiful-and-simple-instagram-app-for-ipad/" class="link">Read the article</a>

                        </span>
                    </div>
                    <div class="slide4">	<span class="media">
    						<span class="headline">"Iris delivers a beautiful Instagram experience on the iPad"</span>
	<a target="_blank" href="http://thenextweb.com/apps/2012/04/19/iris-delivers-the-beautiful-instagram-experience-that-the-ipad-deserves/" class="link">Read the article</a>

                        </span>
                    </div>
                    <div class="slide5">	<span class="media">
    						<span class="headline">"Iris is the best Instagram app for the iPad!"</span>
	<a target="_blank" href="http://theultralinx.com/2012/04/instagram-app-ipad-iris.html" class="link">Read the article</a>

                        </span>
                    </div>
                </div>
            </div>
            <div class="content">
                <div class="spacer"></div>
                <div class="snip clearfix">
                    <div class="left">
                         <h2>Browsing Instagram on your iPad has never been so beautiful!</h2>

                        <p>It's been long over due and finally it's here! Iris is an Instragram client for the iPad that enables you to do virtually everything you can do in Instagram. Browsing thru photos with Apple's beautiful "Retina Display" is breath taking.</p>
                    </div>
                    <div class="right a"></div>
                </div>
                <div class="snip clearfix">
                    <div class="left">
                         <h2>See all your friends photos in beautiful HD quality.</h2>

                        <p>Never lose context of where you are. Its important as a user that while you are looking at photos in their full view, that you are not lost or taken away from that experience when making comments, or seeing others who liked the photo.</p>
                    </div>
                    <div class="right b"></div>
                </div>
                <div class="snip clearfix">
                    <div class="left">
                         <h2>See full profiles of Instagram users and where they took their photos.</h2>

                        <p>Seeing all your friends photos is only one part of the delightful profile view on Iris. You can also see where they took them. That's right. Simply pull up the map and see where the Instagram photos were taken.</p>
                    </div>
                    <div class="right c"></div>
                </div>
                <div class="snip clearfix">
                    <div class="spacer"></div>
                     <h3 class="more">More Instagram Features Offered In Iris</h3>

                    <div class="feat clearfix">
                        <div class="one">
                            <div class="heart">
                                <p>Like and even unlike any photo from any where by simply double tapping the photo!</p>
                            </div>
                            <div class="twitter">
                                <p>See something you like? Share it on Twitter by simply tapping an elarged photo.</p>
                            </div>
                            <div class="place">
                                <p>Sometimes you want to know where a photo was taken. Well now you can see detailed maps of where users have taken photos.</p>
                            </div>
                        </div>
                        <div class="two">
                            <div class="search">
                                <p>Searching for Instagram users or tags is super easy to use. Never know who you might find!</p>
                            </div>
                            <div class="hd">
                                <p>Full Retina Display support was a must! Iris takes advantage of the New iPad's beautiful HD screen!</p>
                            </div>
                            <div class="peeps">
                                <p>Find a friend or user that you think someone else might like? Let them know by reccomending them from the profile.</p>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
            <div class="footer">
                <p>Copyright © 2012 Iris App <a href="http://itunes.apple.com/us/app/id518827330?mt=8&ign-mpt=uo%3D6">Get Iris</a><a href="https://irisapp.zendesk.com/home">Support</a><a href="http://www.EricHoffman.me">The Designer</a><a href="http://www.nicholasleby.com/">The Developer</a>

                </p>
            </div>
        </div>
        <script type="text/javascript">
            $(document).ready(function () {
                $('#features').jshowoff();
            });
        </script>
        <script type="text/javascript">
            (function ($) {
                $(window).scroll(function () {});
            })(jQuery);
        </script>
    </body>

</html>