jQuery(document).ready(function($) {
    $('#eyecatcher_fader')
        .before('<div id="fader_nav">')
        .cycle(
        {
            fx:     'fade',
            speed:  2000,
            timeout: 4000
            /*prev:   '#prev',
             next:   '#next',
             pager:  '#fader_nav'*/
        });
});


// remap jQuery to $
(function($) {

    /* ######## CYCLE ########## */
    /*!
     * jQuery Cycle Plugin (with Transition Definitions)
     * Examples and documentation at: http://jquery.malsup.com/cycle/
     * Copyright (c) 2007-2010 M. Alsup
     * Version: 2.94 (20-DEC-2010)
     * Dual licensed under the MIT and GPL licenses.
     * http://jquery.malsup.com/license.html
     * Requires: jQuery v1.2.6 or later
     */
    ;
    (function($) {

        var ver = '2.94';

        // if $.support is not defined (pre jQuery 1.3) add what I need
        if ($.support == undefined) {
            $.support = {
                opacity: !($.browser.msie)
            };
        }

        function debug(s) {
            if ($.fn.cycle.debug)
                log(s);
        }

        function log() {
            if (window.console && window.console.log)
                window.console.log('[cycle] ' + Array.prototype.join.call(arguments, ' '));
        }

        ;

        // the options arg can be...
        //   a number  - indicates an immediate transition should occur to the given slide index
        //   a string  - 'pause', 'resume', 'toggle', 'next', 'prev', 'stop', 'destroy' or the name of a transition effect (ie, 'fade', 'zoom', etc)
        //   an object - properties to control the slideshow
        //
        // the arg2 arg can be...
        //   the name of an fx (only used in conjunction with a numeric value for 'options')
        //   the value true (only used in first arg == 'resume') and indicates
        //	 that the resume should occur immediately (not wait for next timeout)

        $.fn.cycle = function(options, arg2) {
            var o = { s: this.selector, c: this.context };

            // in 1.3+ we can fix mistakes with the ready state
            if (this.length === 0 && options != 'stop') {
                if (!$.isReady && o.s) {
                    log('DOM not ready, queuing slideshow');
                    $(function() {
                        $(o.s, o.c).cycle(options, arg2);
                    });
                    return this;
                }
                // is your DOM ready?  http://docs.jquery.com/Tutorials:Introducing_$(document).ready()
                log('terminating; zero elements found by selector' + ($.isReady ? '' : ' (DOM not ready)'));
                return this;
            }

            // iterate the matched nodeset
            return this.each(function() {
                var opts = handleArguments(this, options, arg2);
                if (opts === false)
                    return;

                opts.updateActivePagerLink = opts.updateActivePagerLink || $.fn.cycle.updateActivePagerLink;

                // stop existing slideshow for this container (if there is one)
                if (this.cycleTimeout)
                    clearTimeout(this.cycleTimeout);
                this.cycleTimeout = this.cyclePause = 0;

                var $cont = $(this);
                var $slides = opts.slideExpr ? $(opts.slideExpr, this) : $cont.children();
                var els = $slides.get();
                if (els.length < 2) {
                    log('terminating; too few slides: ' + els.length);
                    return;
                }

                var opts2 = buildOptions($cont, $slides, els, opts, o);
                if (opts2 === false)
                    return;

                var startTime = opts2.continuous ? 10 : getTimeout(els[opts2.currSlide], els[opts2.nextSlide], opts2, !opts2.backwards);

                // if it's an auto slideshow, kick it off
                if (startTime) {
                    startTime += (opts2.delay || 0);
                    if (startTime < 10)
                        startTime = 10;
                    debug('first timeout: ' + startTime);
                    this.cycleTimeout = setTimeout(function() {
                        go(els, opts2, 0, !opts.backwards)
                    }, startTime);
                }
            });
        };

        // process the args that were passed to the plugin fn
        function handleArguments(cont, options, arg2) {
            if (cont.cycleStop == undefined)
                cont.cycleStop = 0;
            if (options === undefined || options === null)
                options = {};
            if (options.constructor == String) {
                switch (options) {
                    case 'destroy':
                    case 'stop':
                        var opts = $(cont).data('cycle.opts');
                        if (!opts)
                            return false;
                        cont.cycleStop++; // callbacks look for change
                        if (cont.cycleTimeout)
                            clearTimeout(cont.cycleTimeout);
                        cont.cycleTimeout = 0;
                        $(cont).removeData('cycle.opts');
                        if (options == 'destroy')
                            destroy(opts);
                        return false;
                    case 'toggle':
                        cont.cyclePause = (cont.cyclePause === 1) ? 0 : 1;
                        checkInstantResume(cont.cyclePause, arg2, cont);
                        return false;
                    case 'pause':
                        cont.cyclePause = 1;
                        return false;
                    case 'resume':
                        cont.cyclePause = 0;
                        checkInstantResume(false, arg2, cont);
                        return false;
                    case 'prev':
                    case 'next':
                        var opts = $(cont).data('cycle.opts');
                        if (!opts) {
                            log('options not found, "prev/next" ignored');
                            return false;
                        }
                        $.fn.cycle[options](opts);
                        return false;
                    default:
                        options = { fx: options };
                }
                ;
                return options;
            }
            else if (options.constructor == Number) {
                // go to the requested slide
                var num = options;
                options = $(cont).data('cycle.opts');
                if (!options) {
                    log('options not found, can not advance slide');
                    return false;
                }
                if (num < 0 || num >= options.elements.length) {
                    log('invalid slide index: ' + num);
                    return false;
                }
                options.nextSlide = num;
                if (cont.cycleTimeout) {
                    clearTimeout(cont.cycleTimeout);
                    cont.cycleTimeout = 0;
                }
                if (typeof arg2 == 'string')
                    options.oneTimeFx = arg2;
                go(options.elements, options, 1, num >= options.currSlide);
                return false;
            }
            return options;

            function checkInstantResume(isPaused, arg2, cont) {
                if (!isPaused && arg2 === true) { // resume now!
                    var options = $(cont).data('cycle.opts');
                    if (!options) {
                        log('options not found, can not resume');
                        return false;
                    }
                    if (cont.cycleTimeout) {
                        clearTimeout(cont.cycleTimeout);
                        cont.cycleTimeout = 0;
                    }
                    go(options.elements, options, 1, !options.backwards);
                }
            }
        }

        ;

        function removeFilter(el, opts) {
            if (!$.support.opacity && opts.cleartype && el.style.filter) {
                try {
                    el.style.removeAttribute('filter');
                }
                catch(smother) {
                } // handle old opera versions
            }
        }

        ;

        // unbind event handlers
        function destroy(opts) {
            if (opts.next)
                $(opts.next).unbind(opts.prevNextEvent);
            if (opts.prev)
                $(opts.prev).unbind(opts.prevNextEvent);

            if (opts.pager || opts.pagerAnchorBuilder)
                $.each(opts.pagerAnchors || [], function() {
                    this.unbind().remove();
                });
            opts.pagerAnchors = null;
            if (opts.destroy) // callback
                opts.destroy(opts);
        }

        ;

        // one-time initialization
        function buildOptions($cont, $slides, els, options, o) {
            // support metadata plugin (v1.0 and v2.0)
            var opts = $.extend({}, $.fn.cycle.defaults, options || {}, $.metadata ? $cont.metadata() : $.meta ? $cont.data() : {});
            if (opts.autostop)
                opts.countdown = opts.autostopCount || els.length;

            var cont = $cont[0];
            $cont.data('cycle.opts', opts);
            opts.$cont = $cont;
            opts.stopCount = cont.cycleStop;
            opts.elements = els;
            opts.before = opts.before ? [opts.before] : [];
            opts.after = opts.after ? [opts.after] : [];
            opts.after.unshift(function() {
                opts.busy = 0;
            });

            // push some after callbacks
            if (!$.support.opacity && opts.cleartype)
                opts.after.push(function() {
                    removeFilter(this, opts);
                });
            if (opts.continuous)
                opts.after.push(function() {
                    go(els, opts, 0, !opts.backwards);
                });

            saveOriginalOpts(opts);

            // clearType corrections
            if (!$.support.opacity && opts.cleartype && !opts.cleartypeNoBg)
                clearTypeFix($slides);

            // container requires non-static position so that slides can be position within
            if ($cont.css('position') == 'static')
                $cont.css('position', 'relative');
            if (opts.width)
                $cont.width(opts.width);
            if (opts.height && opts.height != 'auto')
                $cont.height(opts.height);

            if (opts.startingSlide)
                opts.startingSlide = parseInt(opts.startingSlide);
            else if (opts.backwards)
                opts.startingSlide = els.length - 1;

            // if random, mix up the slide array
            if (opts.random) {
                opts.randomMap = [];
                for (var i = 0; i < els.length; i++)
                    opts.randomMap.push(i);
                opts.randomMap.sort(function(a, b) {
                    return Math.random() - 0.5;
                });
                opts.randomIndex = 1;
                opts.startingSlide = opts.randomMap[1];
            }
            else if (opts.startingSlide >= els.length)
                opts.startingSlide = 0; // catch bogus input
            opts.currSlide = opts.startingSlide || 0;
            var first = opts.startingSlide;

            // set position and zIndex on all the slides
            $slides.css({position: 'absolute', top:0, left:0}).hide().each(function(i) {
                var z;
                if (opts.backwards)
                    z = first ? i <= first ? els.length + (i - first) : first - i : els.length - i;
                else
                    z = first ? i >= first ? els.length - (i - first) : first - i : els.length - i;
                $(this).css('z-index', z)
            });

            // make sure first slide is visible
            $(els[first]).css('opacity', 1).show(); // opacity bit needed to handle restart use case
            removeFilter(els[first], opts);

            // stretch slides
            if (opts.fit && opts.width)
                $slides.width(opts.width);
            if (opts.fit && opts.height && opts.height != 'auto')
                $slides.height(opts.height);

            // stretch container
            var reshape = opts.containerResize && !$cont.innerHeight();
            if (reshape) { // do this only if container has no size http://tinyurl.com/da2oa9
                var maxw = 0, maxh = 0;
                for (var j = 0; j < els.length; j++) {
                    var $e = $(els[j]), e = $e[0], w = $e.outerWidth(), h = $e.outerHeight();
                    if (!w) w = e.offsetWidth || e.width || $e.attr('width')
                    if (!h) h = e.offsetHeight || e.height || $e.attr('height');
                    maxw = w > maxw ? w : maxw;
                    maxh = h > maxh ? h : maxh;
                }
                if (maxw > 0 && maxh > 0)
                    $cont.css({width:maxw + 'px',height:maxh + 'px'});
            }

            if (opts.pause)
                $cont.hover(function() {
                    this.cyclePause++;
                }, function() {
                    this.cyclePause--;
                });

            if (supportMultiTransitions(opts) === false)
                return false;

            // apparently a lot of people use image slideshows without height/width attributes on the images.
            // Cycle 2.50+ requires the sizing info for every slide; this block tries to deal with that.
            var requeue = false;
            options.requeueAttempts = options.requeueAttempts || 0;
            $slides.each(function() {
                // try to get height/width of each slide
                var $el = $(this);
                this.cycleH = (opts.fit && opts.height) ? opts.height : ($el.height() || this.offsetHeight || this.height || $el.attr('height') || 0);
                this.cycleW = (opts.fit && opts.width) ? opts.width : ($el.width() || this.offsetWidth || this.width || $el.attr('width') || 0);

                if ($el.is('img')) {
                    // sigh..  sniffing, hacking, shrugging...  this crappy hack tries to account for what browsers do when
                    // an image is being downloaded and the markup did not include sizing info (height/width attributes);
                    // there seems to be some "default" sizes used in this situation
                    var loadingIE = ($.browser.msie && this.cycleW == 28 && this.cycleH == 30 && !this.complete);
                    var loadingFF = ($.browser.mozilla && this.cycleW == 34 && this.cycleH == 19 && !this.complete);
                    var loadingOp = ($.browser.opera && ((this.cycleW == 42 && this.cycleH == 19) || (this.cycleW == 37 && this.cycleH == 17)) && !this.complete);
                    var loadingOther = (this.cycleH == 0 && this.cycleW == 0 && !this.complete);
                    // don't requeue for images that are still loading but have a valid size
                    if (loadingIE || loadingFF || loadingOp || loadingOther) {
                        if (o.s && opts.requeueOnImageNotLoaded && ++options.requeueAttempts < 100) { // track retry count so we don't loop forever
                            log(options.requeueAttempts, ' - img slide not loaded, requeuing slideshow: ', this.src, this.cycleW, this.cycleH);
                            setTimeout(function() {
                                $(o.s, o.c).cycle(options)
                            }, opts.requeueTimeout);
                            requeue = true;
                            return false; // break each loop
                        }
                        else {
                            log('could not determine size of image: ' + this.src, this.cycleW, this.cycleH);
                        }
                    }
                }
                return true;
            });

            if (requeue)
                return false;

            opts.cssBefore = opts.cssBefore || {};
            opts.animIn = opts.animIn || {};
            opts.animOut = opts.animOut || {};

            $slides.not(':eq(' + first + ')').css(opts.cssBefore);
            if (opts.cssFirst)
                $($slides[first]).css(opts.cssFirst);

            if (opts.timeout) {
                opts.timeout = parseInt(opts.timeout);
                // ensure that timeout and speed settings are sane
                if (opts.speed.constructor == String)
                    opts.speed = $.fx.speeds[opts.speed] || parseInt(opts.speed);
                if (!opts.sync)
                    opts.speed = opts.speed / 2;

                var buffer = opts.fx == 'shuffle' ? 500 : 250;
                while ((opts.timeout - opts.speed) < buffer) // sanitize timeout
                    opts.timeout += opts.speed;
            }
            if (opts.easing)
                opts.easeIn = opts.easeOut = opts.easing;
            if (!opts.speedIn)
                opts.speedIn = opts.speed;
            if (!opts.speedOut)
                opts.speedOut = opts.speed;

            opts.slideCount = els.length;
            opts.currSlide = opts.lastSlide = first;
            if (opts.random) {
                if (++opts.randomIndex == els.length)
                    opts.randomIndex = 0;
                opts.nextSlide = opts.randomMap[opts.randomIndex];
            }
            else if (opts.backwards)
                opts.nextSlide = opts.startingSlide == 0 ? (els.length - 1) : opts.startingSlide - 1;
            else
                opts.nextSlide = opts.startingSlide >= (els.length - 1) ? 0 : opts.startingSlide + 1;

            // run transition init fn
            if (!opts.multiFx) {
                var init = $.fn.cycle.transitions[opts.fx];
                if ($.isFunction(init))
                    init($cont, $slides, opts);
                else if (opts.fx != 'custom' && !opts.multiFx) {
                    log('unknown transition: ' + opts.fx, '; slideshow terminating');
                    return false;
                }
            }

            // fire artificial events
            var e0 = $slides[first];
            if (opts.before.length)
                opts.before[0].apply(e0, [e0, e0, opts, true]);
            if (opts.after.length > 1)
                opts.after[1].apply(e0, [e0, e0, opts, true]);

            if (opts.next)
                $(opts.next).bind(opts.prevNextEvent, function() {
                    return advance(opts, 1)
                });
            if (opts.prev)
                $(opts.prev).bind(opts.prevNextEvent, function() {
                    return advance(opts, 0)
                });
            if (opts.pager || opts.pagerAnchorBuilder)
                buildPager(els, opts);

            exposeAddSlide(opts, els);

            return opts;
        }

        ;

        // save off original opts so we can restore after clearing state
        function saveOriginalOpts(opts) {
            opts.original = { before: [], after: [] };
            opts.original.cssBefore = $.extend({}, opts.cssBefore);
            opts.original.cssAfter = $.extend({}, opts.cssAfter);
            opts.original.animIn = $.extend({}, opts.animIn);
            opts.original.animOut = $.extend({}, opts.animOut);
            $.each(opts.before, function() {
                opts.original.before.push(this);
            });
            $.each(opts.after, function() {
                opts.original.after.push(this);
            });
        }

        ;

        function supportMultiTransitions(opts) {
            var i, tx, txs = $.fn.cycle.transitions;
            // look for multiple effects
            if (opts.fx.indexOf(',') > 0) {
                opts.multiFx = true;
                opts.fxs = opts.fx.replace(/\s*/g, '').split(',');
                // discard any bogus effect names
                for (i = 0; i < opts.fxs.length; i++) {
                    var fx = opts.fxs[i];
                    tx = txs[fx];
                    if (!tx || !txs.hasOwnProperty(fx) || !$.isFunction(tx)) {
                        log('discarding unknown transition: ', fx);
                        opts.fxs.splice(i, 1);
                        i--;
                    }
                }
                // if we have an empty list then we threw everything away!
                if (!opts.fxs.length) {
                    log('No valid transitions named; slideshow terminating.');
                    return false;
                }
            }
            else if (opts.fx == 'all') {  // auto-gen the list of transitions
                opts.multiFx = true;
                opts.fxs = [];
                for (p in txs) {
                    tx = txs[p];
                    if (txs.hasOwnProperty(p) && $.isFunction(tx))
                        opts.fxs.push(p);
                }
            }
            if (opts.multiFx && opts.randomizeEffects) {
                // munge the fxs array to make effect selection random
                var r1 = Math.floor(Math.random() * 20) + 30;
                for (i = 0; i < r1; i++) {
                    var r2 = Math.floor(Math.random() * opts.fxs.length);
                    opts.fxs.push(opts.fxs.splice(r2, 1)[0]);
                }
                debug('randomized fx sequence: ', opts.fxs);
            }
            return true;
        }

        ;

        // provide a mechanism for adding slides after the slideshow has started
        function exposeAddSlide(opts, els) {
            opts.addSlide = function(newSlide, prepend) {
                var $s = $(newSlide), s = $s[0];
                if (!opts.autostopCount)
                    opts.countdown++;
                els[prepend ? 'unshift' : 'push'](s);
                if (opts.els)
                    opts.els[prepend ? 'unshift' : 'push'](s); // shuffle needs this
                opts.slideCount = els.length;

                $s.css('position', 'absolute');
                $s[prepend ? 'prependTo' : 'appendTo'](opts.$cont);

                if (prepend) {
                    opts.currSlide++;
                    opts.nextSlide++;
                }

                if (!$.support.opacity && opts.cleartype && !opts.cleartypeNoBg)
                    clearTypeFix($s);

                if (opts.fit && opts.width)
                    $s.width(opts.width);
                if (opts.fit && opts.height && opts.height != 'auto')
                    $s.height(opts.height);
                s.cycleH = (opts.fit && opts.height) ? opts.height : $s.height();
                s.cycleW = (opts.fit && opts.width) ? opts.width : $s.width();

                $s.css(opts.cssBefore);

                if (opts.pager || opts.pagerAnchorBuilder)
                    $.fn.cycle.createPagerAnchor(els.length - 1, s, $(opts.pager), els, opts);

                if ($.isFunction(opts.onAddSlide))
                    opts.onAddSlide($s);
                else
                    $s.hide(); // default behavior
            };
        }

        // reset internal state; we do this on every pass in order to support multiple effects
        $.fn.cycle.resetState = function(opts, fx) {
            fx = fx || opts.fx;
            opts.before = [];
            opts.after = [];
            opts.cssBefore = $.extend({}, opts.original.cssBefore);
            opts.cssAfter = $.extend({}, opts.original.cssAfter);
            opts.animIn = $.extend({}, opts.original.animIn);
            opts.animOut = $.extend({}, opts.original.animOut);
            opts.fxFn = null;
            $.each(opts.original.before, function() {
                opts.before.push(this);
            });
            $.each(opts.original.after, function() {
                opts.after.push(this);
            });

            // re-init
            var init = $.fn.cycle.transitions[fx];
            if ($.isFunction(init))
                init(opts.$cont, $(opts.elements), opts);
        };

        // this is the main engine fn, it handles the timeouts, callbacks and slide index mgmt
        function go(els, opts, manual, fwd) {
            // opts.busy is true if we're in the middle of an animation
            if (manual && opts.busy && opts.manualTrump) {
                // let manual transitions requests trump active ones
                debug('manualTrump in go(), stopping active transition');
                $(els).stop(true, true);
                opts.busy = false;
            }
            // don't begin another timeout-based transition if there is one active
            if (opts.busy) {
                debug('transition active, ignoring new tx request');
                return;
            }

            var p = opts.$cont[0], curr = els[opts.currSlide], next = els[opts.nextSlide];

            // stop cycling if we have an outstanding stop request
            if (p.cycleStop != opts.stopCount || p.cycleTimeout === 0 && !manual)
                return;

            // check to see if we should stop cycling based on autostop options
            if (!manual && !p.cyclePause && !opts.bounce &&
                ((opts.autostop && (--opts.countdown <= 0)) ||
                    (opts.nowrap && !opts.random && opts.nextSlide < opts.currSlide))) {
                if (opts.end)
                    opts.end(opts);
                return;
            }

            // if slideshow is paused, only transition on a manual trigger
            var changed = false;
            if ((manual || !p.cyclePause) && (opts.nextSlide != opts.currSlide)) {
                changed = true;
                var fx = opts.fx;
                // keep trying to get the slide size if we don't have it yet
                curr.cycleH = curr.cycleH || $(curr).height();
                curr.cycleW = curr.cycleW || $(curr).width();
                next.cycleH = next.cycleH || $(next).height();
                next.cycleW = next.cycleW || $(next).width();

                // support multiple transition types
                if (opts.multiFx) {
                    if (opts.lastFx == undefined || ++opts.lastFx >= opts.fxs.length)
                        opts.lastFx = 0;
                    fx = opts.fxs[opts.lastFx];
                    opts.currFx = fx;
                }

                // one-time fx overrides apply to:  $('div').cycle(3,'zoom');
                if (opts.oneTimeFx) {
                    fx = opts.oneTimeFx;
                    opts.oneTimeFx = null;
                }

                $.fn.cycle.resetState(opts, fx);

                // run the before callbacks
                if (opts.before.length)
                    $.each(opts.before, function(i, o) {
                        if (p.cycleStop != opts.stopCount) return;
                        o.apply(next, [curr, next, opts, fwd]);
                    });

                // stage the after callacks
                var after = function() {
                    $.each(opts.after, function(i, o) {
                        if (p.cycleStop != opts.stopCount) return;
                        o.apply(next, [curr, next, opts, fwd]);
                    });
                };

                debug('tx firing; currSlide: ' + opts.currSlide + '; nextSlide: ' + opts.nextSlide);

                // get ready to perform the transition
                opts.busy = 1;
                if (opts.fxFn) // fx function provided?
                    opts.fxFn(curr, next, opts, after, fwd, manual && opts.fastOnEvent);
                else if ($.isFunction($.fn.cycle[opts.fx])) // fx plugin ?
                    $.fn.cycle[opts.fx](curr, next, opts, after, fwd, manual && opts.fastOnEvent);
                else
                    $.fn.cycle.custom(curr, next, opts, after, fwd, manual && opts.fastOnEvent);
            }

            if (changed || opts.nextSlide == opts.currSlide) {
                // calculate the next slide
                opts.lastSlide = opts.currSlide;
                if (opts.random) {
                    opts.currSlide = opts.nextSlide;
                    if (++opts.randomIndex == els.length)
                        opts.randomIndex = 0;
                    opts.nextSlide = opts.randomMap[opts.randomIndex];
                    if (opts.nextSlide == opts.currSlide)
                        opts.nextSlide = (opts.currSlide == opts.slideCount - 1) ? 0 : opts.currSlide + 1;
                }
                else if (opts.backwards) {
                    var roll = (opts.nextSlide - 1) < 0;
                    if (roll && opts.bounce) {
                        opts.backwards = !opts.backwards;
                        opts.nextSlide = 1;
                        opts.currSlide = 0;
                    }
                    else {
                        opts.nextSlide = roll ? (els.length - 1) : opts.nextSlide - 1;
                        opts.currSlide = roll ? 0 : opts.nextSlide + 1;
                    }
                }
                else { // sequence
                    var roll = (opts.nextSlide + 1) == els.length;
                    if (roll && opts.bounce) {
                        opts.backwards = !opts.backwards;
                        opts.nextSlide = els.length - 2;
                        opts.currSlide = els.length - 1;
                    }
                    else {
                        opts.nextSlide = roll ? 0 : opts.nextSlide + 1;
                        opts.currSlide = roll ? els.length - 1 : opts.nextSlide - 1;
                    }
                }
            }
            if (changed && opts.pager)
                opts.updateActivePagerLink(opts.pager, opts.currSlide, opts.activePagerClass);

            // stage the next transition
            var ms = 0;
            if (opts.timeout && !opts.continuous)
                ms = getTimeout(els[opts.currSlide], els[opts.nextSlide], opts, fwd);
            else if (opts.continuous && p.cyclePause) // continuous shows work off an after callback, not this timer logic
                ms = 10;
            if (ms > 0)
                p.cycleTimeout = setTimeout(function() {
                    go(els, opts, 0, !opts.backwards)
                }, ms);
        }

        ;

        // invoked after transition
        $.fn.cycle.updateActivePagerLink = function(pager, currSlide, clsName) {
            $(pager).each(function() {
                $(this).children().removeClass(clsName).eq(currSlide).addClass(clsName);
            });
        };

        // calculate timeout value for current transition
        function getTimeout(curr, next, opts, fwd) {
            if (opts.timeoutFn) {
                // call user provided calc fn
                var t = opts.timeoutFn.call(curr, curr, next, opts, fwd);
                while ((t - opts.speed) < 250) // sanitize timeout
                    t += opts.speed;
                debug('calculated timeout: ' + t + '; speed: ' + opts.speed);
                if (t !== false)
                    return t;
            }
            return opts.timeout;
        }

        ;

        // expose next/prev function, caller must pass in state
        $.fn.cycle.next = function(opts) {
            advance(opts, 1);
        };
        $.fn.cycle.prev = function(opts) {
            advance(opts, 0);
        };

        // advance slide forward or back
        function advance(opts, moveForward) {
            var val = moveForward ? 1 : -1;
            var els = opts.elements;
            var p = opts.$cont[0], timeout = p.cycleTimeout;
            if (timeout) {
                clearTimeout(timeout);
                p.cycleTimeout = 0;
            }
            if (opts.random && val < 0) {
                // move back to the previously display slide
                opts.randomIndex--;
                if (--opts.randomIndex == -2)
                    opts.randomIndex = els.length - 2;
                else if (opts.randomIndex == -1)
                    opts.randomIndex = els.length - 1;
                opts.nextSlide = opts.randomMap[opts.randomIndex];
            }
            else if (opts.random) {
                opts.nextSlide = opts.randomMap[opts.randomIndex];
            }
            else {
                opts.nextSlide = opts.currSlide + val;
                if (opts.nextSlide < 0) {
                    if (opts.nowrap) return false;
                    opts.nextSlide = els.length - 1;
                }
                else if (opts.nextSlide >= els.length) {
                    if (opts.nowrap) return false;
                    opts.nextSlide = 0;
                }
            }

            var cb = opts.onPrevNextEvent || opts.prevNextClick; // prevNextClick is deprecated
            if ($.isFunction(cb))
                cb(val > 0, opts.nextSlide, els[opts.nextSlide]);
            go(els, opts, 1, moveForward);
            return false;
        }

        ;

        function buildPager(els, opts) {
            var $p = $(opts.pager);
            $.each(els, function(i, o) {
                $.fn.cycle.createPagerAnchor(i, o, $p, els, opts);
            });
            opts.updateActivePagerLink(opts.pager, opts.startingSlide, opts.activePagerClass);
        }

        ;

        $.fn.cycle.createPagerAnchor = function(i, el, $p, els, opts) {
            var a;
            if ($.isFunction(opts.pagerAnchorBuilder)) {
                a = opts.pagerAnchorBuilder(i, el);
                debug('pagerAnchorBuilder(' + i + ', el) returned: ' + a);
            }
            else
                a = '<a href="#">' + (i + 1) + '</a>';

            if (!a)
                return;
            var $a = $(a);
            // don't reparent if anchor is in the dom
            if ($a.parents('body').length === 0) {
                var arr = [];
                if ($p.length > 1) {
                    $p.each(function() {
                        var $clone = $a.clone(true);
                        $(this).append($clone);
                        arr.push($clone[0]);
                    });
                    $a = $(arr);
                }
                else {
                    $a.appendTo($p);
                }
            }

            opts.pagerAnchors = opts.pagerAnchors || [];
            opts.pagerAnchors.push($a);
            $a.bind(opts.pagerEvent, function(e) {
                e.preventDefault();
                opts.nextSlide = i;
                var p = opts.$cont[0], timeout = p.cycleTimeout;
                if (timeout) {
                    clearTimeout(timeout);
                    p.cycleTimeout = 0;
                }
                var cb = opts.onPagerEvent || opts.pagerClick; // pagerClick is deprecated
                if ($.isFunction(cb))
                    cb(opts.nextSlide, els[opts.nextSlide]);
                go(els, opts, 1, opts.currSlide < i); // trigger the trans
                //		return false; // <== allow bubble
            });

            if (! /^click/.test(opts.pagerEvent) && !opts.allowPagerClickBubble)
                $a.bind('click.cycle', function() {
                    return false;
                }); // suppress click

            if (opts.pauseOnPagerHover)
                $a.hover(function() {
                    opts.$cont[0].cyclePause++;
                }, function() {
                    opts.$cont[0].cyclePause--;
                });
        };

        // helper fn to calculate the number of slides between the current and the next
        $.fn.cycle.hopsFromLast = function(opts, fwd) {
            var hops, l = opts.lastSlide, c = opts.currSlide;
            if (fwd)
                hops = c > l ? c - l : opts.slideCount - l;
            else
                hops = c < l ? l - c : l + opts.slideCount - c;
            return hops;
        };

        // fix clearType problems in ie6 by setting an explicit bg color
        // (otherwise text slides look horrible during a fade transition)
        function clearTypeFix($slides) {
            debug('applying clearType background-color hack');
            function hex(s) {
                s = parseInt(s).toString(16);
                return s.length < 2 ? '0' + s : s;
            }

            ;
            function getBg(e) {
                for (; e && e.nodeName.toLowerCase() != 'html'; e = e.parentNode) {
                    var v = $.css(e, 'background-color');
                    if (v.indexOf('rgb') >= 0) {
                        var rgb = v.match(/\d+/g);
                        return '#' + hex(rgb[0]) + hex(rgb[1]) + hex(rgb[2]);
                    }
                    if (v && v != 'transparent')
                        return v;
                }
                return '#ffffff';
            }

            ;
            $slides.each(function() {
                $(this).css('background-color', getBg(this));
            });
        }

        ;

        // reset common props before the next transition
        $.fn.cycle.commonReset = function(curr, next, opts, w, h, rev) {
            $(opts.elements).not(curr).hide();
            opts.cssBefore.opacity = 1;
            opts.cssBefore.display = 'block';
            if (opts.slideResize && w !== false && next.cycleW > 0)
                opts.cssBefore.width = next.cycleW;
            if (opts.slideResize && h !== false && next.cycleH > 0)
                opts.cssBefore.height = next.cycleH;
            opts.cssAfter = opts.cssAfter || {};
            opts.cssAfter.display = 'none';
            $(curr).css('zIndex', opts.slideCount + (rev === true ? 1 : 0));
            $(next).css('zIndex', opts.slideCount + (rev === true ? 0 : 1));
        };

        // the actual fn for effecting a transition
        $.fn.cycle.custom = function(curr, next, opts, cb, fwd, speedOverride) {
            var $l = $(curr), $n = $(next);
            var speedIn = opts.speedIn, speedOut = opts.speedOut, easeIn = opts.easeIn, easeOut = opts.easeOut;
            $n.css(opts.cssBefore);
            if (speedOverride) {
                if (typeof speedOverride == 'number')
                    speedIn = speedOut = speedOverride;
                else
                    speedIn = speedOut = 1;
                easeIn = easeOut = null;
            }
            var fn = function() {
                $n.animate(opts.animIn, speedIn, easeIn, cb)
            };
            $l.animate(opts.animOut, speedOut, easeOut, function() {
                if (opts.cssAfter) $l.css(opts.cssAfter);
                if (!opts.sync) fn();
            });
            if (opts.sync) fn();
        };

        // transition definitions - only fade is defined here, transition pack defines the rest
        $.fn.cycle.transitions = {
            fade: function($cont, $slides, opts) {
                $slides.not(':eq(' + opts.currSlide + ')').css('opacity', 0);
                opts.before.push(function(curr, next, opts) {
                    $.fn.cycle.commonReset(curr, next, opts);
                    opts.cssBefore.opacity = 0;
                });
                opts.animIn = { opacity: 1 };
                opts.animOut = { opacity: 0 };
                opts.cssBefore = { top: 0, left: 0 };
            }
        };

        $.fn.cycle.ver = function() {
            return ver;
        };

        // override these globally if you like (they are all optional)
        $.fn.cycle.defaults = {
            fx:              'fade', // name of transition effect (or comma separated names, ex: 'fade,scrollUp,shuffle')
            timeout:       4000,  // milliseconds between slide transitions (0 to disable auto advance)
            timeoutFn:     null,  // callback for determining per-slide timeout value:  function(currSlideElement, nextSlideElement, options, forwardFlag)
            continuous:       0,      // true to start next transition immediately after current one completes
            speed:           1000,  // speed of the transition (any valid fx speed value)
            speedIn:       null,  // speed of the 'in' transition
            speedOut:       null,  // speed of the 'out' transition
            next:           null,  // selector for element to use as event trigger for next slide
            prev:           null,  // selector for element to use as event trigger for previous slide
            //	prevNextClick: null,  // @deprecated; please use onPrevNextEvent instead
            onPrevNextEvent: null,  // callback fn for prev/next events: function(isNext, zeroBasedSlideIndex, slideElement)
            prevNextEvent:'click.cycle',// event which drives the manual transition to the previous or next slide
            pager:           null,  // selector for element to use as pager container
            //pagerClick   null,  // @deprecated; please use onPagerEvent instead
            onPagerEvent:  null,  // callback fn for pager events: function(zeroBasedSlideIndex, slideElement)
            pagerEvent:      'click.cycle', // name of event which drives the pager navigation
            allowPagerClickBubble: false, // allows or prevents click event on pager anchors from bubbling
            pagerAnchorBuilder: null, // callback fn for building anchor links:  function(index, DOMelement)
            before:           null,  // transition callback (scope set to element to be shown):	 function(currSlideElement, nextSlideElement, options, forwardFlag)
            after:           null,  // transition callback (scope set to element that was shown):  function(currSlideElement, nextSlideElement, options, forwardFlag)
            end:           null,  // callback invoked when the slideshow terminates (use with autostop or nowrap options): function(options)
            easing:           null,  // easing method for both in and out transitions
            easeIn:           null,  // easing for "in" transition
            easeOut:       null,  // easing for "out" transition
            shuffle:       null,  // coords for shuffle animation, ex: { top:15, left: 200 }
            animIn:           null,  // properties that define how the slide animates in
            animOut:       null,  // properties that define how the slide animates out
            cssBefore:       null,  // properties that define the initial state of the slide before transitioning in
            cssAfter:       null,  // properties that defined the state of the slide after transitioning out
            fxFn:           null,  // function used to control the transition: function(currSlideElement, nextSlideElement, options, afterCalback, forwardFlag)
            height:          'auto', // container height
            startingSlide: 0,      // zero-based index of the first slide to be displayed
            sync:           1,      // true if in/out transitions should occur simultaneously
            random:           0,      // true for random, false for sequence (not applicable to shuffle fx)
            fit:           0,      // force slides to fit container
            containerResize: 1,      // resize container to fit largest slide
            slideResize:   1,     // force slide width/height to fixed size before every transition
            pause:           0,      // true to enable "pause on hover"
            pauseOnPagerHover: 0, // true to pause when hovering over pager link
            autostop:       0,      // true to end slideshow after X transitions (where X == slide count)
            autostopCount: 0,      // number of transitions (optionally used with autostop to define X)
            delay:           0,      // additional delay (in ms) for first transition (hint: can be negative)
            slideExpr:       null,  // expression for selecting slides (if something other than all children is required)
            cleartype:       !$.support.opacity,  // true if clearType corrections should be applied (for IE)
            cleartypeNoBg: false, // set to true to disable extra cleartype fixing (leave false to force background color setting on slides)
            nowrap:           0,      // true to prevent slideshow from wrapping
            fastOnEvent:   0,      // force fast transitions when triggered manually (via pager or prev/next); value == time in ms
            randomizeEffects: 1,  // valid when multiple effects are used; true to make the effect sequence random
            rev:           0,      // causes animations to transition in reverse (for effects that support it such as scrollHorz/scrollVert/shuffle)
            manualTrump:   true,  // causes manual transition to stop an active transition instead of being ignored
            requeueOnImageNotLoaded: true, // requeue the slideshow if any image slides are not yet loaded
            requeueTimeout: 250,  // ms delay for requeue
            activePagerClass: 'activeSlide', // class name used for the active pager link
            updateActivePagerLink: null, // callback fn invoked to update the active pager link (adds/removes activePagerClass style)
            backwards:     false  // true to start slideshow at last slide and move backwards through the stack
        };

    })(jQuery);


    /*!
     * jQuery Cycle Plugin Transition Definitions
     * This script is a plugin for the jQuery Cycle Plugin
     * Examples and documentation at: http://malsup.com/jquery/cycle/
     * Copyright (c) 2007-2010 M. Alsup
     * Version:	 2.73
     * Dual licensed under the MIT and GPL licenses:
     * http://www.opensource.org/licenses/mit-license.php
     * http://www.gnu.org/licenses/gpl.html
     */
    (function($) {

        //
        // These functions define one-time slide initialization for the named
        // transitions. To save file size feel free to remove any of these that you
        // don't need.
        //
        $.fn.cycle.transitions.none = function($cont, $slides, opts) {
            opts.fxFn = function(curr, next, opts, after) {
                $(next).show();
                $(curr).hide();
                after();
            };
        }
        // not a cross-fade, fadeout only fades out the top slide
        $.fn.cycle.transitions.fadeout = function($cont, $slides, opts) {
            $slides.not(':eq(' + opts.currSlide + ')').css({ display: 'block', 'opacity': 1 });
            opts.before.push(function(curr, next, opts, w, h, rev) {
                $(curr).css('zIndex', opts.slideCount + (!rev === true ? 1 : 0));
                $(next).css('zIndex', opts.slideCount + (!rev === true ? 0 : 1));
            });
            opts.animIn = { opacity: 1 };
            opts.animOut = { opacity: 0 };
            opts.cssBefore = { opacity: 1, display: 'block' };
            opts.cssAfter = { zIndex: 0 };
        };

        // scrollUp/Down/Left/Right
        $.fn.cycle.transitions.scrollUp = function($cont, $slides, opts) {
            $cont.css('overflow', 'hidden');
            opts.before.push($.fn.cycle.commonReset);
            var h = $cont.height();
            opts.cssBefore = { top: h, left: 0 };
            opts.cssFirst = { top: 0 };
            opts.animIn = { top: 0 };
            opts.animOut = { top: -h };
        };
        $.fn.cycle.transitions.scrollDown = function($cont, $slides, opts) {
            $cont.css('overflow', 'hidden');
            opts.before.push($.fn.cycle.commonReset);
            var h = $cont.height();
            opts.cssFirst = { top: 0 };
            opts.cssBefore = { top: -h, left: 0 };
            opts.animIn = { top: 0 };
            opts.animOut = { top: h };
        };
        $.fn.cycle.transitions.scrollLeft = function($cont, $slides, opts) {
            $cont.css('overflow', 'hidden');
            opts.before.push($.fn.cycle.commonReset);
            var w = $cont.width();
            opts.cssFirst = { left: 0 };
            opts.cssBefore = { left: w, top: 0 };
            opts.animIn = { left: 0 };
            opts.animOut = { left: 0 - w };
        };
        $.fn.cycle.transitions.scrollRight = function($cont, $slides, opts) {
            $cont.css('overflow', 'hidden');
            opts.before.push($.fn.cycle.commonReset);
            var w = $cont.width();
            opts.cssFirst = { left: 0 };
            opts.cssBefore = { left: -w, top: 0 };
            opts.animIn = { left: 0 };
            opts.animOut = { left: w };
        };
        $.fn.cycle.transitions.scrollHorz = function($cont, $slides, opts) {
            $cont.css('overflow', 'hidden').width();
            opts.before.push(function(curr, next, opts, fwd) {
                if (opts.rev)
                    fwd = !fwd;
                $.fn.cycle.commonReset(curr, next, opts);
                opts.cssBefore.left = fwd ? (next.cycleW - 1) : (1 - next.cycleW);
                opts.animOut.left = fwd ? -curr.cycleW : curr.cycleW;
            });
            opts.cssFirst = { left: 0 };
            opts.cssBefore = { top: 0 };
            opts.animIn = { left: 0 };
            opts.animOut = { top: 0 };
        };
        $.fn.cycle.transitions.scrollVert = function($cont, $slides, opts) {
            $cont.css('overflow', 'hidden');
            opts.before.push(function(curr, next, opts, fwd) {
                if (opts.rev)
                    fwd = !fwd;
                $.fn.cycle.commonReset(curr, next, opts);
                opts.cssBefore.top = fwd ? (1 - next.cycleH) : (next.cycleH - 1);
                opts.animOut.top = fwd ? curr.cycleH : -curr.cycleH;
            });
            opts.cssFirst = { top: 0 };
            opts.cssBefore = { left: 0 };
            opts.animIn = { top: 0 };
            opts.animOut = { left: 0 };
        };

        // slideX/slideY
        $.fn.cycle.transitions.slideX = function($cont, $slides, opts) {
            opts.before.push(function(curr, next, opts) {
                $(opts.elements).not(curr).hide();
                $.fn.cycle.commonReset(curr, next, opts, false, true);
                opts.animIn.width = next.cycleW;
            });
            opts.cssBefore = { left: 0, top: 0, width: 0 };
            opts.animIn = { width: 'show' };
            opts.animOut = { width: 0 };
        };
        $.fn.cycle.transitions.slideY = function($cont, $slides, opts) {
            opts.before.push(function(curr, next, opts) {
                $(opts.elements).not(curr).hide();
                $.fn.cycle.commonReset(curr, next, opts, true, false);
                opts.animIn.height = next.cycleH;
            });
            opts.cssBefore = { left: 0, top: 0, height: 0 };
            opts.animIn = { height: 'show' };
            opts.animOut = { height: 0 };
        };

        // shuffle
        $.fn.cycle.transitions.shuffle = function($cont, $slides, opts) {
            var i, w = $cont.css('overflow', 'visible').width();
            $slides.css({left: 0, top: 0});
            opts.before.push(function(curr, next, opts) {
                $.fn.cycle.commonReset(curr, next, opts, true, true, true);
            });
            // only adjust speed once!
            if (!opts.speedAdjusted) {
                opts.speed = opts.speed / 2; // shuffle has 2 transitions
                opts.speedAdjusted = true;
            }
            opts.random = 0;
            opts.shuffle = opts.shuffle || {left:-w, top:15};
            opts.els = [];
            for (i = 0; i < $slides.length; i++)
                opts.els.push($slides[i]);

            for (i = 0; i < opts.currSlide; i++)
                opts.els.push(opts.els.shift());

            // custom transition fn (hat tip to Benjamin Sterling for this bit of sweetness!)
            opts.fxFn = function(curr, next, opts, cb, fwd) {
                if (opts.rev)
                    fwd = !fwd;
                var $el = fwd ? $(curr) : $(next);
                $(next).css(opts.cssBefore);
                var count = opts.slideCount;
                $el.animate(opts.shuffle, opts.speedIn, opts.easeIn, function() {
                    var hops = $.fn.cycle.hopsFromLast(opts, fwd);
                    for (var k = 0; k < hops; k++)
                        fwd ? opts.els.push(opts.els.shift()) : opts.els.unshift(opts.els.pop());
                    if (fwd) {
                        for (var i = 0, len = opts.els.length; i < len; i++)
                            $(opts.els[i]).css('z-index', len - i + count);
                    }
                    else {
                        var z = $(curr).css('z-index');
                        $el.css('z-index', parseInt(z) + 1 + count);
                    }
                    $el.animate({left:0, top:0}, opts.speedOut, opts.easeOut, function() {
                        $(fwd ? this : curr).hide();
                        if (cb) cb();
                    });
                });
            };
            opts.cssBefore = { display: 'block', opacity: 1, top: 0, left: 0 };
        };

        // turnUp/Down/Left/Right
        $.fn.cycle.transitions.turnUp = function($cont, $slides, opts) {
            opts.before.push(function(curr, next, opts) {
                $.fn.cycle.commonReset(curr, next, opts, true, false);
                opts.cssBefore.top = next.cycleH;
                opts.animIn.height = next.cycleH;
                opts.animOut.width = next.cycleW;
            });
            opts.cssFirst = { top: 0 };
            opts.cssBefore = { left: 0, height: 0 };
            opts.animIn = { top: 0 };
            opts.animOut = { height: 0 };
        };
        $.fn.cycle.transitions.turnDown = function($cont, $slides, opts) {
            opts.before.push(function(curr, next, opts) {
                $.fn.cycle.commonReset(curr, next, opts, true, false);
                opts.animIn.height = next.cycleH;
                opts.animOut.top = curr.cycleH;
            });
            opts.cssFirst = { top: 0 };
            opts.cssBefore = { left: 0, top: 0, height: 0 };
            opts.animOut = { height: 0 };
        };
        $.fn.cycle.transitions.turnLeft = function($cont, $slides, opts) {
            opts.before.push(function(curr, next, opts) {
                $.fn.cycle.commonReset(curr, next, opts, false, true);
                opts.cssBefore.left = next.cycleW;
                opts.animIn.width = next.cycleW;
            });
            opts.cssBefore = { top: 0, width: 0  };
            opts.animIn = { left: 0 };
            opts.animOut = { width: 0 };
        };
        $.fn.cycle.transitions.turnRight = function($cont, $slides, opts) {
            opts.before.push(function(curr, next, opts) {
                $.fn.cycle.commonReset(curr, next, opts, false, true);
                opts.animIn.width = next.cycleW;
                opts.animOut.left = curr.cycleW;
            });
            opts.cssBefore = { top: 0, left: 0, width: 0 };
            opts.animIn = { left: 0 };
            opts.animOut = { width: 0 };
        };

        // zoom
        $.fn.cycle.transitions.zoom = function($cont, $slides, opts) {
            opts.before.push(function(curr, next, opts) {
                $.fn.cycle.commonReset(curr, next, opts, false, false, true);
                opts.cssBefore.top = next.cycleH / 2;
                opts.cssBefore.left = next.cycleW / 2;
                opts.animIn = { top: 0, left: 0, width: next.cycleW, height: next.cycleH };
                opts.animOut = { width: 0, height: 0, top: curr.cycleH / 2, left: curr.cycleW / 2 };
            });
            opts.cssFirst = { top:0, left: 0 };
            opts.cssBefore = { width: 0, height: 0 };
        };

        // fadeZoom
        $.fn.cycle.transitions.fadeZoom = function($cont, $slides, opts) {
            opts.before.push(function(curr, next, opts) {
                $.fn.cycle.commonReset(curr, next, opts, false, false);
                opts.cssBefore.left = next.cycleW / 2;
                opts.cssBefore.top = next.cycleH / 2;
                opts.animIn = { top: 0, left: 0, width: next.cycleW, height: next.cycleH };
            });
            opts.cssBefore = { width: 0, height: 0 };
            opts.animOut = { opacity: 0 };
        };

        // blindX
        $.fn.cycle.transitions.blindX = function($cont, $slides, opts) {
            var w = $cont.css('overflow', 'hidden').width();
            opts.before.push(function(curr, next, opts) {
                $.fn.cycle.commonReset(curr, next, opts);
                opts.animIn.width = next.cycleW;
                opts.animOut.left = curr.cycleW;
            });
            opts.cssBefore = { left: w, top: 0 };
            opts.animIn = { left: 0 };
            opts.animOut = { left: w };
        };
        // blindY
        $.fn.cycle.transitions.blindY = function($cont, $slides, opts) {
            var h = $cont.css('overflow', 'hidden').height();
            opts.before.push(function(curr, next, opts) {
                $.fn.cycle.commonReset(curr, next, opts);
                opts.animIn.height = next.cycleH;
                opts.animOut.top = curr.cycleH;
            });
            opts.cssBefore = { top: h, left: 0 };
            opts.animIn = { top: 0 };
            opts.animOut = { top: h };
        };
        // blindZ
        $.fn.cycle.transitions.blindZ = function($cont, $slides, opts) {
            var h = $cont.css('overflow', 'hidden').height();
            var w = $cont.width();
            opts.before.push(function(curr, next, opts) {
                $.fn.cycle.commonReset(curr, next, opts);
                opts.animIn.height = next.cycleH;
                opts.animOut.top = curr.cycleH;
            });
            opts.cssBefore = { top: h, left: w };
            opts.animIn = { top: 0, left: 0 };
            opts.animOut = { top: h, left: w };
        };

        // growX - grow horizontally from centered 0 width
        $.fn.cycle.transitions.growX = function($cont, $slides, opts) {
            opts.before.push(function(curr, next, opts) {
                $.fn.cycle.commonReset(curr, next, opts, false, true);
                opts.cssBefore.left = this.cycleW / 2;
                opts.animIn = { left: 0, width: this.cycleW };
                opts.animOut = { left: 0 };
            });
            opts.cssBefore = { width: 0, top: 0 };
        };
        // growY - grow vertically from centered 0 height
        $.fn.cycle.transitions.growY = function($cont, $slides, opts) {
            opts.before.push(function(curr, next, opts) {
                $.fn.cycle.commonReset(curr, next, opts, true, false);
                opts.cssBefore.top = this.cycleH / 2;
                opts.animIn = { top: 0, height: this.cycleH };
                opts.animOut = { top: 0 };
            });
            opts.cssBefore = { height: 0, left: 0 };
        };

        // curtainX - squeeze in both edges horizontally
        $.fn.cycle.transitions.curtainX = function($cont, $slides, opts) {
            opts.before.push(function(curr, next, opts) {
                $.fn.cycle.commonReset(curr, next, opts, false, true, true);
                opts.cssBefore.left = next.cycleW / 2;
                opts.animIn = { left: 0, width: this.cycleW };
                opts.animOut = { left: curr.cycleW / 2, width: 0 };
            });
            opts.cssBefore = { top: 0, width: 0 };
        };
        // curtainY - squeeze in both edges vertically
        $.fn.cycle.transitions.curtainY = function($cont, $slides, opts) {
            opts.before.push(function(curr, next, opts) {
                $.fn.cycle.commonReset(curr, next, opts, true, false, true);
                opts.cssBefore.top = next.cycleH / 2;
                opts.animIn = { top: 0, height: next.cycleH };
                opts.animOut = { top: curr.cycleH / 2, height: 0 };
            });
            opts.cssBefore = { left: 0, height: 0 };
        };

        // cover - curr slide covered by next slide
        $.fn.cycle.transitions.cover = function($cont, $slides, opts) {
            var d = opts.direction || 'left';
            var w = $cont.css('overflow', 'hidden').width();
            var h = $cont.height();
            opts.before.push(function(curr, next, opts) {
                $.fn.cycle.commonReset(curr, next, opts);
                if (d == 'right')
                    opts.cssBefore.left = -w;
                else if (d == 'up')
                    opts.cssBefore.top = h;
                else if (d == 'down')
                    opts.cssBefore.top = -h;
                else
                    opts.cssBefore.left = w;
            });
            opts.animIn = { left: 0, top: 0};
            opts.animOut = { opacity: 1 };
            opts.cssBefore = { top: 0, left: 0 };
        };

        // uncover - curr slide moves off next slide
        $.fn.cycle.transitions.uncover = function($cont, $slides, opts) {
            var d = opts.direction || 'left';
            var w = $cont.css('overflow', 'hidden').width();
            var h = $cont.height();
            opts.before.push(function(curr, next, opts) {
                $.fn.cycle.commonReset(curr, next, opts, true, true, true);
                if (d == 'right')
                    opts.animOut.left = w;
                else if (d == 'up')
                    opts.animOut.top = -h;
                else if (d == 'down')
                    opts.animOut.top = h;
                else
                    opts.animOut.left = -w;
            });
            opts.animIn = { left: 0, top: 0 };
            opts.animOut = { opacity: 1 };
            opts.cssBefore = { top: 0, left: 0 };
        };

        // toss - move top slide and fade away
        $.fn.cycle.transitions.toss = function($cont, $slides, opts) {
            var w = $cont.css('overflow', 'visible').width();
            var h = $cont.height();
            opts.before.push(function(curr, next, opts) {
                $.fn.cycle.commonReset(curr, next, opts, true, true, true);
                // provide default toss settings if animOut not provided
                if (!opts.animOut.left && !opts.animOut.top)
                    opts.animOut = { left: w * 2, top: -h / 2, opacity: 0 };
                else
                    opts.animOut.opacity = 0;
            });
            opts.cssBefore = { left: 0, top: 0 };
            opts.animIn = { left: 0 };
        };

        // wipe - clip animation
        $.fn.cycle.transitions.wipe = function($cont, $slides, opts) {
            var w = $cont.css('overflow', 'hidden').width();
            var h = $cont.height();
            opts.cssBefore = opts.cssBefore || {};
            var clip;
            if (opts.clip) {
                if (/l2r/.test(opts.clip))
                    clip = 'rect(0px 0px ' + h + 'px 0px)';
                else if (/r2l/.test(opts.clip))
                    clip = 'rect(0px ' + w + 'px ' + h + 'px ' + w + 'px)';
                else if (/t2b/.test(opts.clip))
                    clip = 'rect(0px ' + w + 'px 0px 0px)';
                else if (/b2t/.test(opts.clip))
                    clip = 'rect(' + h + 'px ' + w + 'px ' + h + 'px 0px)';
                else if (/zoom/.test(opts.clip)) {
                    var top = parseInt(h / 2);
                    var left = parseInt(w / 2);
                    clip = 'rect(' + top + 'px ' + left + 'px ' + top + 'px ' + left + 'px)';
                }
            }

            opts.cssBefore.clip = opts.cssBefore.clip || clip || 'rect(0px 0px 0px 0px)';

            var d = opts.cssBefore.clip.match(/(\d+)/g);
            var t = parseInt(d[0]), r = parseInt(d[1]), b = parseInt(d[2]), l = parseInt(d[3]);

            opts.before.push(function(curr, next, opts) {
                if (curr == next) return;
                var $curr = $(curr), $next = $(next);
                $.fn.cycle.commonReset(curr, next, opts, true, true, false);
                opts.cssAfter.display = 'block';

                var step = 1, count = parseInt((opts.speedIn / 13)) - 1;
                (function f() {
                    var tt = t ? t - parseInt(step * (t / count)) : 0;
                    var ll = l ? l - parseInt(step * (l / count)) : 0;
                    var bb = b < h ? b + parseInt(step * ((h - b) / count || 1)) : h;
                    var rr = r < w ? r + parseInt(step * ((w - r) / count || 1)) : w;
                    $next.css({ clip: 'rect(' + tt + 'px ' + rr + 'px ' + bb + 'px ' + ll + 'px)' });
                    (step++ <= count) ? setTimeout(f, 13) : $curr.css('display', 'none');
                })();
            });
            opts.cssBefore = { display: 'block', opacity: 1, top: 0, left: 0 };
            opts.animIn = { left: 0 };
            opts.animOut = { left: 0 };
        };


    })(jQuery);

    /* ######## CYCLE END ########## */
    /*----------------------------------------*/


})(this.jQuery);

/* ######## GHIX BOOKING ########## */
var datePickerDivID = "datepicker";
var iFrameDivID = "datepickeriframe";

var dayArrayShort = new Array('Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa');
var dayArrayMed = new Array('Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat');
var dayArrayLong = new Array('Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday');
var monthArrayShort = new Array('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec');
var monthArrayMed = new Array('Jan', 'Feb', 'Mar', 'Apr', 'May', 'June', 'July', 'Aug', 'Sept', 'Oct', 'Nov', 'Dec');
var monthArrayLong = new Array('January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December');

var defaultDateSeparator = ".";
var defaultDateFormat = "dmy";
var dateSeparator = defaultDateSeparator;
var dateFormat = defaultDateFormat;

// for current date

function displayDatePicker(dateFieldName, displayBelowThisObject, dtFormat, dtSep) {
    var targetDateField = document.getElementsByName(dateFieldName).item(0);

    if (!displayBelowThisObject)
        displayBelowThisObject = targetDateField;

    if (dtSep)
        dateSeparator = dtSep;
    else
        dateSeparator = defaultDateSeparator;

    if (dtFormat)
        dateFormat = dtFormat;
    else
        dateFormat = defaultDateFormat;

    var x = displayBelowThisObject.offsetLeft;
    var y = displayBelowThisObject.offsetTop + displayBelowThisObject.offsetHeight;

    var parent = displayBelowThisObject;
    while (parent.offsetParent) {
        parent = parent.offsetParent;
        x += parent.offsetLeft;
        y += parent.offsetTop;
    }

    drawDatePicker(targetDateField, x, y);
}

function drawDatePicker(targetDateField, x, y) {
    var dt = getFieldDate(targetDateField.value);

    if (!document.getElementById(datePickerDivID)) {
        var newNode = document.createElement("div");
        newNode.setAttribute("id", datePickerDivID);
        newNode.setAttribute("class", "dpDiv");
        newNode.setAttribute("style", "visibility: hidden;");
        document.body.appendChild(newNode);
    }

    // customizing: define datepicker position in global stylesheet
    var pickerDiv = document.getElementById(datePickerDivID);
    pickerDiv.style.position = "absolute";
    pickerDiv.style.left = x + "px";
    pickerDiv.style.top = y + "px";
    pickerDiv.style.visibility = (pickerDiv.style.visibility == "visible" ? "hidden" : "visible");
    pickerDiv.style.display = (pickerDiv.style.display == "block" ? "none" : "block");
    pickerDiv.style.zIndex = 10000;
    // end customizing

    refreshDatePicker(targetDateField.name, dt.getFullYear(), dt.getMonth(), dt.getDate());
}

function refreshDatePicker(dateFieldName, year, month, day) {
    var thisDay = new Date();

    if ((month >= 0) && (year > 0)) {
        thisDay = new Date(year, month, 1);
    } else {
        day = thisDay.getDate();
        thisDay.setDate(1);
    }

    var crlf = "\r\n";
    var TABLE = "<table cols=7 class='dpTable'>" + crlf;
    var xTABLE = "</table>" + crlf;
    var TR = "<tr class='dpTR'>";
    var TR_title = "<tr class='dpTitleTR'>";
    var TR_days = "<tr class='dpDayTR'>";
    var TR_todaybutton = "<tr class='dpTodayButtonTR'>";
    var xTR = "</tr>" + crlf;
    var TD = "<td class='dpTD' onMouseOut='this.className=\"dpTD\";' onMouseOver=' this.className=\"dpTDHover\";' ";
    var TD_title = "<td colspan=5 class='dpTitleTD'>";
    var TD_buttons = "<td class='dpButtonTD'>";
    var TD_todaybutton = "<td colspan=7 class='dpTodayButtonTD'>";
    var TD_days = "<td class='dpDayTD'>";
    var TD_selected = "<td class='dpDayHighlightTD' onMouseOut='this.className=\"dpDayHighlightTD\";' onMouseOver='this.className=\"dpTDHover\";' ";
    var xTD = "</td>" + crlf;
    var DIV_title = "<div class='dpTitleText'>";
    var DIV_selected = "<div class='dpDayHighlight'>";
    var xDIV = "</div>";

    var html = TABLE;

    html += TR_title;
// customizing: style next / prev icon
    //html += TD_buttons + getButtonCode(dateFieldName, thisDay, -1, "&lt;") + xTD;
    html += TD_buttons + getButtonCode(dateFieldName, thisDay, -1, "<img src=themes/walliserhof/images/lt_bullet.png / >") + xTD;
    html += TD_title + DIV_title + monthArrayLong[ thisDay.getMonth()] + " " + thisDay.getFullYear() + xDIV + xTD;
    //html += TD_buttons + getButtonCode(dateFieldName, thisDay, 1, "&gt;") + xTD;
    html += TD_buttons + getButtonCode(dateFieldName, thisDay, 1, "<img src=themes/walliserhof/images/gt_bullet.png / >") + xTD;
    html += xTR;
// end customizing

    html += TR_days;
    for (i = 0; i < dayArrayShort.length; i++)
        html += TD_days + dayArrayShort[i] + xTD;
    html += xTR;

    html += TR;

    for (i = 0; i < thisDay.getDay(); i++)
        html += TD + "&nbsp;" + xTD;

    do {
        dayNum = thisDay.getDate();
        TD_onclick = " onclick=\"updateDateField('" + dateFieldName + "', '" + getDateString(thisDay) + "');\">";

        if (dayNum == day)
            html += TD_selected + TD_onclick + DIV_selected + dayNum + xDIV + xTD;
        else
            html += TD + TD_onclick + dayNum + xTD;

        if (thisDay.getDay() == 6)
            html += xTR + TR;

        thisDay.setDate(thisDay.getDate() + 1);
    } while (thisDay.getDate() > 1)

    if (thisDay.getDay() > 0) {
        for (i = 6; i > thisDay.getDay(); i--)
            html += TD + "&nbsp;" + xTD;
    }
    html += xTR;

    var today = new Date();
    var todayString = "Today is " + dayArrayMed[today.getDay()] + ", " + monthArrayMed[ today.getMonth()] + " " + today.getDate();
    html += TR_todaybutton + TD_todaybutton;
    html += "<button class='dpTodayButton' onClick='refreshDatePicker(\"" + dateFieldName + "\");'>this month</button> ";
    html += "<button class='dpTodayButton' onClick='updateDateField(\"" + dateFieldName + "\");'>close</button>";
    html += xTD + xTR;

    html += xTABLE;

    document.getElementById(datePickerDivID).innerHTML = html;
    adjustiFrame();
}

function getButtonCode(dateFieldName, dateVal, adjust, label) {
    var newMonth = (dateVal.getMonth() + adjust) % 12;
    var newYear = dateVal.getFullYear() + parseInt((dateVal.getMonth() + adjust) / 12);
    if (newMonth < 0) {
        newMonth += 12;
        newYear += -1;
    }

    return "<button class='dpButton' onClick='refreshDatePicker(\"" + dateFieldName + "\", " + newYear + ", " + newMonth + ");'>" + label + "</button>";
}

function getDateString(dateVal) {
    var dayString = "00" + dateVal.getDate();
    var monthString = "00" + (dateVal.getMonth() + 1);
    dayString = dayString.substring(dayString.length - 2);
    monthString = monthString.substring(monthString.length - 2);

    switch (dateFormat) {
        case "dmy" :
            return dayString + dateSeparator + monthString + dateSeparator + dateVal.getFullYear();
        case "ymd" :
            return dateVal.getFullYear() + dateSeparator + monthString + dateSeparator + dayString;
        case "mdy" :
        default :
            return monthString + dateSeparator + dayString + dateSeparator + dateVal.getFullYear();
    }
}

function getFieldDate(dateString) {
    var dateVal;
    var dArray;
    var d, m, y;

    try {
        dArray = splitDateString(dateString);
        if (dArray) {
            switch (dateFormat) {
                case "dmy" :
                    d = parseInt(dArray[0], 10);
                    m = parseInt(dArray[1], 10) - 1;
                    y = parseInt(dArray[2], 10);
                    break;
                case "ymd" :
                    d = parseInt(dArray[2], 10);
                    m = parseInt(dArray[1], 10) - 1;
                    y = parseInt(dArray[0], 10);
                    break;
                case "mdy" :
                default :
                    d = parseInt(dArray[1], 10);
                    m = parseInt(dArray[0], 10) - 1;
                    y = parseInt(dArray[2], 10);
                    break;
            }
            dateVal = new Date(y, m, d);
        } else if (dateString) {
            dateVal = new Date(dateString);
        } else {
            dateVal = new Date();
        }
    } catch(e) {
        dateVal = new Date();
    }

    return dateVal;
}


function splitDateString(dateString) {
    var dArray;
    if (dateString.indexOf("/") >= 0)
        dArray = dateString.split("/");
    else if (dateString.indexOf(".") >= 0)
        dArray = dateString.split(".");
    else if (dateString.indexOf("-") >= 0)
        dArray = dateString.split("-");
    else if (dateString.indexOf("\\") >= 0)
        dArray = dateString.split("\\");
    else
        dArray = false;

    return dArray;
}

/**
 Update the field with the given dateFieldName with the dateString that has been passed,
 and hide the datepicker. If no dateString is passed, just close the datepicker without
 changing the field value.

 Also, if the page developer has defined a function called datePickerClosed anywhere on
 the page or in an imported library, we will attempt to run that function with the updated
 field as a parameter. This can be used for such things as date validation, setting default
 values for related fields, etc. For example, you might have a function like this to validate
 a start date field:

 function datePickerClosed(dateField)
 {
 var dateObj = getFieldDate(dateField.value);
 var today = new Date();
 today = new Date(today.getFullYear(), today.getMonth(), today.getDate());

 if (dateField.name == "StartDate") {
 if (dateObj < today) {
 // if the date is before today, alert the user and display the datepicker again
 alert("Please enter a date that is today or later");
 dateField.value = "";
 document.getElementById(datePickerDivID).style.visibility = "visible";
 adjustiFrame();
 } else {
 // if the date is okay, set the EndDate field to 7 days after the StartDate
 dateObj.setTime(dateObj.getTime() + (7 * 24 * 60 * 60 * 1000));
 var endDateField = document.getElementsByName ("EndDate").item(0);
 endDateField.value = getDateString(dateObj);
 }
 }
 }

 */
function updateDateField(dateFieldName, dateString) {
    var targetDateField = document.getElementsByName(dateFieldName).item(0);
    if (dateString)
        targetDateField.value = dateString;

    var pickerDiv = document.getElementById(datePickerDivID);

    // customizing: don't hide datepicker if date is picket up
    pickerDiv.style.visibility = "hidden";
    pickerDiv.style.display = "none";
    // end customizing

    adjustiFrame();
    targetDateField.focus();

    if ((dateString) && (typeof(datePickerClosed) == "function"))
        datePickerClosed(targetDateField);
}

function adjustiFrame(pickerDiv, iFrameDiv) {
    var is_opera = (navigator.userAgent.toLowerCase().indexOf("opera") != -1);
    if (is_opera)
        return;

    try {
        if (!document.getElementById(iFrameDivID)) {
            var newNode = document.createElement("iFrame");
            newNode.setAttribute("id", iFrameDivID);
            newNode.setAttribute("src", "javascript:false;");
            newNode.setAttribute("scrolling", "no");
            newNode.setAttribute("frameborder", "0");
            document.body.appendChild(newNode);
        }

        if (!pickerDiv)
            pickerDiv = document.getElementById(datePickerDivID);
        if (!iFrameDiv)
            iFrameDiv = document.getElementById(iFrameDivID);

        try {
            iFrameDiv.style.position = "absolute";
            iFrameDiv.style.width = pickerDiv.offsetWidth;
            iFrameDiv.style.height = pickerDiv.offsetHeight;
            iFrameDiv.style.top = pickerDiv.style.top;
            iFrameDiv.style.left = pickerDiv.style.left;
            iFrameDiv.style.zIndex = pickerDiv.style.zIndex - 1;
            iFrameDiv.style.visibility = pickerDiv.style.visibility;
            iFrameDiv.style.display = pickerDiv.style.display;
        } catch(e) {
        }

    } catch (ee) {
    }

}

// customizing: always show datepicker
//displayDatePicker('tdate', false, 'dmy', '.');
// end customizing
/* ######## GHIX BOOKING END ########## */
/*----------------------------------------*/

// usage: log('inside coolFunc',this,arguments);
// paulirish.com/2009/log-a-lightweight-wrapper-for-consolelog/
window.log = function() {
    log.history = log.history || [];   // store logs to an array for reference
    log.history.push(arguments);
    if (this.console) {
        console.log(Array.prototype.slice.call(arguments));
    }
};

// catch all document.write() calls
(function(doc) {
    var write = doc.write;
    doc.write = function(q) {
        log('document.write(): ', arguments);
        if (/docwriteregexwhitelist/.test(q)) write.apply(doc, arguments);
    };
})(document);