text:
/**
 * A lightweight CommonJS Promises/A and when() implementation
 * when is part of the cujo.js family of libraries (http://cujojs.com/)
 *
 * Licensed under the MIT License at:
 * http://www.opensource.org/licenses/mit-license.php
 *
 * @author Brian Cavalier
 * @author John Hann
 * @version 2.1.0
 */

(function(define, global) { 'use strict';
define(function () {

	// Public API

	when.defer     = defer;      // Create a deferred
	when.resolve   = resolve;    // Create a resolved promise
	when.reject    = reject;     // Create a rejected promise

	when.join      = join;       // Join 2 or more promises

	when.all       = all;        // Resolve a list of promises
	when.map       = map;        // Array.map() for promises
	when.reduce    = reduce;     // Array.reduce() for promises
	when.settle    = settle;     // Settle a list of promises

	when.any       = any;        // One-winner race
	when.some      = some;       // Multi-winner race

	when.isPromise = isPromise;  // Determine if a thing is a promise

	when.promise   = promise;    // EXPERIMENTAL: May change. Use at your own risk

	/**
	 * Register an observer for a promise or immediate value.
	 *
	 * @param {*} promiseOrValue
	 * @param {function?} [onFulfilled] callback to be called when promiseOrValue is
	 *   successfully fulfilled.  If promiseOrValue is an immediate value, callback
	 *   will be invoked immediately.
	 * @param {function?} [onRejected] callback to be called when promiseOrValue is
	 *   rejected.
	 * @param {function?} [onProgress] callback to be called when progress updates
	 *   are issued for promiseOrValue.
	 * @returns {Promise} a new {@link Promise} that will complete with the return
	 *   value of callback or errback or the completion value of promiseOrValue if
	 *   callback and/or errback is not supplied.
	 */
	function when(promiseOrValue, onFulfilled, onRejected, onProgress) {
		// Get a trusted promise for the input promiseOrValue, and then
		// register promise handlers
		return resolve(promiseOrValue).then(onFulfilled, onRejected, onProgress);
	}

	/**
	 * Trusted Promise constructor.  A Promise created from this constructor is
	 * a trusted when.js promise.  Any other duck-typed promise is considered
	 * untrusted.
	 * @constructor
	 * @name Promise
	 */
	function Promise(then, inspect) {
		this.then = then;
		this.inspect = inspect;
	}

	Promise.prototype = {
		/**
		 * Register a rejection handler.  Shortcut for .then(undefined, onRejected)
		 * @param {function?} onRejected
		 * @return {Promise}
		 */
		otherwise: function(onRejected) {
			return this.then(undef, onRejected);
		},

		/**
		 * Ensures that onFulfilledOrRejected will be called regardless of whether
		 * this promise is fulfilled or rejected.  onFulfilledOrRejected WILL NOT
		 * receive the promises' value or reason.  Any returned value will be disregarded.
		 * onFulfilledOrRejected may throw or return a rejected promise to signal
		 * an additional error.
		 * @param {function} onFulfilledOrRejected handler to be called regardless of
		 *  fulfillment or rejection
		 * @returns {Promise}
		 */
		ensure: function(onFulfilledOrRejected) {
			return this.then(injectHandler, injectHandler).yield(this);

			function injectHandler() {
				return resolve(onFulfilledOrRejected());
			}
		},

		/**
		 * Shortcut for .then(function() { return value; })
		 * @param  {*} value
		 * @return {Promise} a promise that:
		 *  - is fulfilled if value is not a promise, or
		 *  - if value is a promise, will fulfill with its value, or reject
		 *    with its reason.
		 */
		'yield': function(value) {
			return this.then(function() {
				return value;
			});
		},

		/**
		 * Assumes that this promise will fulfill with an array, and arranges
		 * for the onFulfilled to be called with the array as its argument list
		 * i.e. onFulfilled.apply(undefined, array).
		 * @param {function} onFulfilled function to receive spread arguments
		 * @return {Promise}
		 */
		spread: function(onFulfilled) {
			return this.then(function(array) {
				// array may contain promises, so resolve its contents.
				return all(array, function(array) {
					return onFulfilled.apply(undef, array);
				});
			});
		},

		/**
		 * Shortcut for .then(onFulfilledOrRejected, onFulfilledOrRejected)
		 * @deprecated
		 */
		always: function(onFulfilledOrRejected, onProgress) {
			return this.then(onFulfilledOrRejected, onFulfilledOrRejected, onProgress);
		}
	};

	/**
	 * Returns a resolved promise. The returned promise will be
	 *  - fulfilled with promiseOrValue if it is a value, or
	 *  - if promiseOrValue is a promise
	 *    - fulfilled with promiseOrValue's value after it is fulfilled
	 *    - rejected with promiseOrValue's reason after it is rejected
	 * @param  {*} value
	 * @return {Promise}
	 */
	function resolve(value) {
		return promise(function(resolve) {
			resolve(value);
		});
	}

	/**
	 * Returns a rejected promise for the supplied promiseOrValue.  The returned
	 * promise will be rejected with:
	 * - promiseOrValue, if it is a value, or
	 * - if promiseOrValue is a promise
	 *   - promiseOrValue's value after it is fulfilled
	 *   - promiseOrValue's reason after it is rejected
	 * @param {*} promiseOrValue the rejected value of the returned {@link Promise}
	 * @return {Promise} rejected {@link Promise}
	 */
	function reject(promiseOrValue) {
		return when(promiseOrValue, rejected);
	}

	/**
	 * Creates a new Deferred with fully isolated resolver and promise parts,
	 * either or both of which may be given out safely to consumers.
	 * The resolver has resolve, reject, and progress.  The promise
	 * only has then.
	 *
	 * @return {{
	 * promise: Promise,
	 * resolve: function:Promise,
	 * reject: function:Promise,
	 * notify: function:Promise
	 * resolver: {
	 *	resolve: function:Promise,
	 *	reject: function:Promise,
	 *	notify: function:Promise
	 * }}}
	 */
	function defer() {
		var deferred, pending, resolved;

		// Optimize object shape
		deferred = {
			promise: undef, resolve: undef, reject: undef, notify: undef,
			resolver: { resolve: undef, reject: undef, notify: undef }
		};

		deferred.promise = pending = promise(makeDeferred);

		return deferred;

		function makeDeferred(resolvePending, rejectPending, notifyPending) {
			deferred.resolve = deferred.resolver.resolve = function(value) {
				if(resolved) {
					return resolve(value);
				}
				resolved = true;
				resolvePending(value);
				return pending;
			};

			deferred.reject  = deferred.resolver.reject  = function(reason) {
				if(resolved) {
					return resolve(rejected(reason));
				}
				resolved = true;
				rejectPending(reason);
				return pending;
			};

			deferred.notify  = deferred.resolver.notify  = function(update) {
				notifyPending(update);
				return update;
			};
		}
	}

	/**
	 * Creates a new promise whose fate is determined by resolver.
	 * @private (for now)
	 * @param {function} resolver function(resolve, reject, notify)
	 * @returns {Promise} promise whose fate is determine by resolver
	 */
	function promise(resolver) {
		var value, handlers = [];

		// Call the provider resolver to seal the promise's fate
		//try {
			resolver(promiseResolve, promiseReject, promiseNotify);
		//} catch(e) {
		//	promiseReject(e);
		//}

		// Return the promise
		return new Promise(then, inspect);

		/**
		 * Register handlers for this promise.
		 * @param [onFulfilled] {Function} fulfillment handler
		 * @param [onRejected] {Function} rejection handler
		 * @param [onProgress] {Function} progress handler
		 * @return {Promise} new Promise
		 */
		function then(onFulfilled, onRejected, onProgress) {
			return promise(function(resolve, reject, notify) {
				handlers
				// Call handlers later, after resolution
				? handlers.push(function(value) {
					value.then(onFulfilled, onRejected, onProgress)
						.then(resolve, reject, notify);
				})
				// Call handlers soon, but not in the current stack
				: enqueue(function() {
					value.then(onFulfilled, onRejected, onProgress)
						.then(resolve, reject, notify);
				});
			});
		}

		function inspect() {
			return value ? value.inspect() : toPendingState();
		}

		/**
		 * Transition from pre-resolution state to post-resolution state, notifying
		 * all listeners of the ultimate fulfillment or rejection
		 * @param {*|Promise} val resolution value
		 */
		function promiseResolve(val) {
			if(!handlers) {
				return;
			}

			value = coerce(val);
			scheduleHandlers(handlers, value);

			handlers = undef;
		}

		/**
		 * Reject this promise with the supplied reason, which will be used verbatim.
		 * @param {*} reason reason for the rejection
		 */
		function promiseReject(reason) {
			promiseResolve(rejected(reason));
		}

		/**
		 * Issue a progress event, notifying all progress listeners
		 * @param {*} update progress event payload to pass to all listeners
		 */
		function promiseNotify(update) {
			if(handlers) {
				scheduleHandlers(handlers, progressing(update));
			}
		}
	}

	/**
	 * Coerces x to a trusted Promise
	 *
	 * @private
	 * @param {*} x thing to coerce
	 * @returns {Promise} Guaranteed to return a trusted Promise.  If x
	 *   is trusted, returns x, otherwise, returns a new, trusted, already-resolved
	 *   Promise whose resolution value is:
	 *   * the resolution value of x if it's a foreign promise, or
	 *   * x if it's a value
	 */
	function coerce(x) {
		if(x instanceof Promise) {
			return x;
		}

		if (!(x === Object(x) && 'then' in x)) {
			return fulfilled(x);
		}

		return promise(function(resolve, reject, notify) {
			enqueue(function() {
				try {
					// We must check and assimilate in the same tick, but not the
					// current tick, careful only to access promiseOrValue.then once.
					var untrustedThen = x.then;

					if(typeof untrustedThen === 'function') {
						fcall(untrustedThen, x, resolve, reject, notify);
					} else {
						// It's a value, create a fulfilled wrapper
						resolve(fulfilled(x));
					}

				} catch(e) {
					// Something went wrong, reject
					reject(e);
				}
			});
		});
	}

	/**
	 * Create an already-fulfilled promise for the supplied value
	 * @private
	 * @param {*} value
	 * @return {Promise} fulfilled promise
	 */
	function fulfilled(value) {
		var self = new Promise(function (onFulfilled) {
			try {
				return typeof onFulfilled == 'function'
					? coerce(onFulfilled(value)) : self;
			} catch (e) {
				return rejected(e);
			}
		}, function() {
			return toFulfilledState(value);
		});

		return self;
	}

	/**
	 * Create an already-rejected promise with the supplied rejection reason.
	 * @private
	 * @param {*} reason
	 * @return {Promise} rejected promise
	 */
	function rejected(reason) {
		var self = new Promise(function (_, onRejected) {
			try {
				return typeof onRejected == 'function'
					? coerce(onRejected(reason)) : self;
			} catch (e) {
				return rejected(e);
			}
		}, function() {
			return toRejectedState(reason);
		});

		return self;
	}

	/**
	 * Create a progress promise with the supplied update.
	 * @private
	 * @param {*} update
	 * @return {Promise} progress promise
	 */
	function progressing(update) {
		var self = new Promise(function (_, __, onProgress) {
			try {
				return typeof onProgress == 'function'
					? progressing(onProgress(update)) : self;
			} catch (e) {
				return progressing(e);
			}
		});

		return self;
	}

	/**
	 * Schedule a task that will process a list of handlers
	 * in the next queue drain run.
	 * @private
	 * @param {Array} handlers queue of handlers to execute
	 * @param {*} value passed as the only arg to each handler
	 */
	function scheduleHandlers(handlers, value) {
		enqueue(function() {
			var handler, i = 0;
			while (handler = handlers[i++]) {
				handler(value);
			}
		});
	}

	/**
	 * Determines if promiseOrValue is a promise or not
	 *
	 * @param {*} promiseOrValue anything
	 * @returns {boolean} true if promiseOrValue is a {@link Promise}
	 */
	function isPromise(promiseOrValue) {
		return promiseOrValue && typeof promiseOrValue.then === 'function';
	}

	/**
	 * Initiates a competitive race, returning a promise that will resolve when
	 * howMany of the supplied promisesOrValues have resolved, or will reject when
	 * it becomes impossible for howMany to resolve, for example, when
	 * (promisesOrValues.length - howMany) + 1 input promises reject.
	 *
	 * @param {Array} promisesOrValues array of anything, may contain a mix
	 *      of promises and values
	 * @param howMany {number} number of promisesOrValues to resolve
	 * @param {function?} [onFulfilled] DEPRECATED, use returnedPromise.then()
	 * @param {function?} [onRejected] DEPRECATED, use returnedPromise.then()
	 * @param {function?} [onProgress] DEPRECATED, use returnedPromise.then()
	 * @returns {Promise} promise that will resolve to an array of howMany values that
	 *  resolved first, or will reject with an array of
	 *  (promisesOrValues.length - howMany) + 1 rejection reasons.
	 */
	function some(promisesOrValues, howMany, onFulfilled, onRejected, onProgress) {

		return when(promisesOrValues, function(promisesOrValues) {

			return promise(resolveSome).then(onFulfilled, onRejected, onProgress);

			function resolveSome(resolve, reject, notify) {
				var toResolve, toReject, values, reasons, fulfillOne, rejectOne, len, i;

				len = promisesOrValues.length >>> 0;

				toResolve = Math.max(0, Math.min(howMany, len));
				values = [];

				toReject = (len - toResolve) + 1;
				reasons = [];

				// No items in the input, resolve immediately
				if (!toResolve) {
					resolve(values);

				} else {
					rejectOne = function(reason) {
						reasons.push(reason);
						if(!--toReject) {
							fulfillOne = rejectOne = identity;
							reject(reasons);
						}
					};

					fulfillOne = function(val) {
						// This orders the values based on promise resolution order
						values.push(val);
						if (!--toResolve) {
							fulfillOne = rejectOne = identity;
							resolve(values);
						}
					};

					for(i = 0; i < len; ++i) {
						if(i in promisesOrValues) {
							when(promisesOrValues[i], fulfiller, rejecter, notify);
						}
					}
				}

				function rejecter(reason) {
					rejectOne(reason);
				}

				function fulfiller(val) {
					fulfillOne(val);
				}
			}
		});
	}

	/**
	 * Initiates a competitive race, returning a promise that will resolve when
	 * any one of the supplied promisesOrValues has resolved or will reject when
	 * *all* promisesOrValues have rejected.
	 *
	 * @param {Array|Promise} promisesOrValues array of anything, may contain a mix
	 *      of {@link Promise}s and values
	 * @param {function?} [onFulfilled] DEPRECATED, use returnedPromise.then()
	 * @param {function?} [onRejected] DEPRECATED, use returnedPromise.then()
	 * @param {function?} [onProgress] DEPRECATED, use returnedPromise.then()
	 * @returns {Promise} promise that will resolve to the value that resolved first, or
	 * will reject with an array of all rejected inputs.
	 */
	function any(promisesOrValues, onFulfilled, onRejected, onProgress) {

		function unwrapSingleResult(val) {
			return onFulfilled ? onFulfilled(val[0]) : val[0];
		}

		return some(promisesOrValues, 1, unwrapSingleResult, onRejected, onProgress);
	}

	/**
	 * Return a promise that will resolve only once all the supplied promisesOrValues
	 * have resolved. The resolution value of the returned promise will be an array
	 * containing the resolution values of each of the promisesOrValues.
	 * @memberOf when
	 *
	 * @param {Array|Promise} promisesOrValues array of anything, may contain a mix
	 *      of {@link Promise}s and values
	 * @param {function?} [onFulfilled] DEPRECATED, use returnedPromise.then()
	 * @param {function?} [onRejected] DEPRECATED, use returnedPromise.then()
	 * @param {function?} [onProgress] DEPRECATED, use returnedPromise.then()
	 * @returns {Promise}
	 */
	function all(promisesOrValues, onFulfilled, onRejected, onProgress) {
		return _map(promisesOrValues, identity).then(onFulfilled, onRejected, onProgress);
	}

	/**
	 * Joins multiple promises into a single returned promise.
	 * @return {Promise} a promise that will fulfill when *all* the input promises
	 * have fulfilled, or will reject when *any one* of the input promises rejects.
	 */
	function join(/* ...promises */) {
		return _map(arguments, identity);
	}

	/**
	 * Settles all input promises such that they are guaranteed not to
	 * be pending once the returned promise fulfills. The returned promise
	 * will always fulfill, except in the case where `array` is a promise
	 * that rejects.
	 * @param {Array|Promise} array or promise for array of promises to settle
	 * @returns {Promise} promise that always fulfills with an array of
	 *  outcome snapshots for each input promise.
	 */
	function settle(array) {
		return _map(array, toFulfilledState, toRejectedState);
	}

	/**
	 * Promise-aware array map function, similar to `Array.prototype.map()`,
	 * but input array may contain promises or values.
	 * @param {Array|Promise} array array of anything, may contain promises and values
	 * @param {function} mapFunc map function which may return a promise or value
	 * @returns {Promise} promise that will fulfill with an array of mapped values
	 *  or reject if any input promise rejects.
	 */
	function map(array, mapFunc) {
		return _map(array, mapFunc);
	}

	/**
	 * Internal map that allows a fallback to handle rejections
	 * @param {Array|Promise} array array of anything, may contain promises and values
	 * @param {function} mapFunc map function which may return a promise or value
	 * @param {function?} fallback function to handle rejected promises
	 * @returns {Promise} promise that will fulfill with an array of mapped values
	 *  or reject if any input promise rejects.
	 */
	function _map(array, mapFunc, fallback) {
		return when(array, function(array) {

			return promise(resolveMap);

			function resolveMap(resolve, reject, notify) {
				var results, len, toResolve, resolveOne, i;

				// Since we know the resulting length, we can preallocate the results
				// array to avoid array expansions.
				toResolve = len = array.length >>> 0;
				results = [];

				if(!toResolve) {
					resolve(results);
					return;
				}

				resolveOne = function(item, i) {
					when(item, mapFunc, fallback).then(function(mapped) {
						results[i] = mapped;

						if(!--toResolve) {
							resolve(results);
						}
					}, reject, notify);
				};

				// Since mapFunc may be async, get all invocations of it into flight
				for(i = 0; i < len; i++) {
					if(i in array) {
						resolveOne(array[i], i);
					} else {
						--toResolve;
					}
				}
			}
		});
	}

	/**
	 * Traditional reduce function, similar to `Array.prototype.reduce()`, but
	 * input may contain promises and/or values, and reduceFunc
	 * may return either a value or a promise, *and* initialValue may
	 * be a promise for the starting value.
	 *
	 * @param {Array|Promise} promise array or promise for an array of anything,
	 *      may contain a mix of promises and values.
	 * @param {function} reduceFunc reduce function reduce(currentValue, nextValue, index, total),
	 *      where total is the total number of items being reduced, and will be the same
	 *      in each call to reduceFunc.
	 * @returns {Promise} that will resolve to the final reduced value
	 */
	function reduce(promise, reduceFunc /*, initialValue */) {
		var args = fcall(slice, arguments, 1);

		return when(promise, function(array) {
			var total;

			total = array.length;

			// Wrap the supplied reduceFunc with one that handles promises and then
			// delegates to the supplied.
			args[0] = function (current, val, i) {
				return when(current, function (c) {
					return when(val, function (value) {
						return reduceFunc(c, value, i, total);
					});
				});
			};

			return reduceArray.apply(array, args);
		});
	}

	// Snapshot states

	/**
	 * Creates a fulfilled state snapshot
	 * @private
	 * @param {*} x any value
	 * @returns {{state:'fulfilled',value:*}}
	 */
	function toFulfilledState(x) {
		return { state: 'fulfilled', value: x };
	}

	/**
	 * Creates a rejected state snapshot
	 * @private
	 * @param {*} x any reason
	 * @returns {{state:'rejected',reason:*}}
	 */
	function toRejectedState(x) {
		return { state: 'rejected', reason: x };
	}

	/**
	 * Creates a pending state snapshot
	 * @private
	 * @returns {{state:'pending'}}
	 */
	function toPendingState() {
		return { state: 'pending' };
	}

	//
	// Utilities, etc.
	//

	var reduceArray, slice, fcall, nextTick, handlerQueue,
		setTimeout, funcProto, call, arrayProto, undef;

	//
	// Shared handler queue processing
	//
	// Credit to Twisol (https://github.com/Twisol) for suggesting
	// this type of extensible queue + trampoline approach for
	// next-tick conflation.

	handlerQueue = [];

	/**
	 * Enqueue a task. If the queue is not currently scheduled to be
	 * drained, schedule it.
	 * @param {function} task
	 */
	function enqueue(task) {
		if(handlerQueue.push(task) === 1) {
			scheduleDrainQueue();
		}
	}

	/**
	 * Schedule the queue to be drained after the stack has cleared.
	 */
	function scheduleDrainQueue() {
		nextTick(drainQueue);
	}

	/**
	 * Drain the handler queue entirely, being careful to allow the
	 * queue to be extended while it is being processed, and to continue
	 * processing until it is truly empty.
	 */
	function drainQueue() {
		var task, i = 0;

		while(task = handlerQueue[i++]) {
			task();
		}

		handlerQueue = [];
	}

	//
	// Capture function and array utils
	//
	/*global setImmediate,process,vertx*/

	// capture setTimeout to avoid being caught by fake timers used in time based tests
	setTimeout = global.setTimeout;
	// Prefer setImmediate, cascade to node, vertx and finally setTimeout
	nextTick = typeof setImmediate === 'function' ? setImmediate.bind(global)
		: typeof process === 'object' && process.nextTick ? process.nextTick
		: typeof vertx === 'object' ? vertx.runOnLoop // vert.x
			: function(task) { setTimeout(task, 0); }; // fallback

	// Safe function calls
	funcProto = Function.prototype;
	call = funcProto.call;
	fcall = funcProto.bind
		? call.bind(call)
		: function(f, context) {
			return f.apply(context, slice.call(arguments, 2));
		};

	// Safe array ops
	arrayProto = [];
	slice = arrayProto.slice;

	// ES5 reduce implementation if native not available
	// See: http://es5.github.com/#x15.4.4.21 as there are many
	// specifics and edge cases.  ES5 dictates that reduce.length === 1
	// This implementation deviates from ES5 spec in the following ways:
	// 1. It does not check if reduceFunc is a Callable
	reduceArray = arrayProto.reduce ||
		function(reduceFunc /*, initialValue */) {
			/*jshint maxcomplexity: 7*/
			var arr, args, reduced, len, i;

			i = 0;
			arr = Object(this);
			len = arr.length >>> 0;
			args = arguments;

			// If no initialValue, use first item of array (we know length !== 0 here)
			// and adjust i to start at second item
			if(args.length <= 1) {
				// Skip to the first real element in the array
				for(;;) {
					if(i in arr) {
						reduced = arr[i++];
						break;
					}

					// If we reached the end of the array without finding any real
					// elements, it's a TypeError
					if(++i >= len) {
						throw new TypeError();
					}
				}
			} else {
				// If initialValue provided, use it
				reduced = args[1];
			}

			// Do the actual reduce
			for(;i < len; ++i) {
				if(i in arr) {
					reduced = reduceFunc(reduced, arr[i], i, arr);
				}
			}

			return reduced;
		};

	function identity(x) {
		return x;
	}

	return when;
});
})(
	typeof define === 'function' && define.amd ? define : function (factory) {
		if(typeof module != 'undefined'){
			module.exports = factory();
		}else if(typeof window != 'undefined'){
			window.when = factory();
		}
	},
	this
);


text:
/* Generated by less 1.7.0 */
html,
body,
div,
ul,
li,
a,
p,
h1,
h2,
h3,
table,
th,
tr,
td {
  margin: 0;
  padding: 0;
}
body {
  width: 960px;
  font-family: Helvetica, Arial, 'DejaVu Sans', 'Liberation Sans', Freesans, sans-serif;
  font-size: 18px;
}
body div#wrapper ul.accordion {
  margin: 50px;
  list-style-type: none;
  width: 400px;
}
body div#wrapper ul.accordion li {
  border: 1px solid black;
}
body div#wrapper ul.accordion li a.accordion-btn {
  text-align: center;
  text-decoration: none;
  display: block;
  color: #444444;
  font-size: 1.3em;
  font-weight: bold;
  background: #eeeeee;
  background: -moz-linear-gradient(top, #eeeeee 25%, #aaaaaa 75%);
  background: -webkit-gradient(linear, left top, left bottom, color-stop(25%, #eeeeee), color-stop(75%, #aaaaaa));
  background: -webkit-linear-gradient(top, #eeeeee 25%, #aaaaaa 75%);
  background: -o-linear-gradient(top, #eeeeee 25%, #aaaaaa 75%);
  background: -ms-linear-gradient(top, #eeeeee 25%, #aaaaaa 75%);
  background: linear-gradient(to bottom, #eeeeee 25%, #aaaaaa 75%);
  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#eeeeee', endColorstr='#aaaaaa', GradientType=0);
}
body div#wrapper ul.accordion li a.accordion-btn:hover {
  background: #AAAAAA;
}
body div#wrapper ul.accordion li div.accordion-content {
  padding: 5px 15px;
  color: #444444;
  background: #AAAAAA;
}
body div#wrapper ul.accordion li div.accordion-content h1 {
  text-align: center;
  font-size: 1.6em;
  padding: 5px 0;
  color: #5E5E5E;
}
body div#wrapper ul.accordion li div.accordion-content p {
  text-align: justify;
}
body div#wrapper ul.accordion li div.accordion-content table {
  border: 1px solid black;
  margin: 15px 5px;
  border-collapse: collapse;
}
body div#wrapper ul.accordion li div.accordion-content table thead th {
  color: #444444;
  border: 1px solid black;
  padding: 5px;
  background: #ededed;
  background: -moz-linear-gradient(top, #ededed 0%, #898989 100%);
  background: -webkit-gradient(linear, left top, left bottom, color-stop(0%, #ededed), color-stop(100%, #898989));
  background: -webkit-linear-gradient(top, #ededed 0%, #898989 100%);
  background: -o-linear-gradient(top, #ededed 0%, #898989 100%);
  background: -ms-linear-gradient(top, #ededed 0%, #898989 100%);
  background: linear-gradient(to bottom, #ededed 0%, #898989 100%);
  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ededed', endColorstr='#898989', GradientType=0);
}
body div#wrapper ul.accordion li div.accordion-content table thead th:first-of-type {
  border-top-left-radius: 15px;
}
body div#wrapper ul.accordion li div.accordion-content table tbody tr {
  background: #cbcbcb;
  background: -moz-linear-gradient(top, #cbcbcb 0%, #888888 100%);
  background: -webkit-gradient(linear, left top, left bottom, color-stop(0%, #cbcbcb), color-stop(100%, #888888));
  background: -webkit-linear-gradient(top, #cbcbcb 0%, #888888 100%);
  background: -o-linear-gradient(top, #cbcbcb 0%, #888888 100%);
  background: -ms-linear-gradient(top, #cbcbcb 0%, #888888 100%);
  background: linear-gradient(to bottom, #cbcbcb 0%, #888888 100%);
  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#cbcbcb', endColorstr='#888888', GradientType=0);
}
body div#wrapper ul.accordion li div.accordion-content table tbody tr td {
  color: white;
  border: 1px solid black;
  padding: 5px;
}
body div#wrapper ul.accordion li div.accordion-content table tbody tr:nth-child(2n) {
  background: #888888;
  background: -moz-linear-gradient(top, #888888 0%, #cbcbcb 100%);
  background: -webkit-gradient(linear, left top, left bottom, color-stop(0%, #888888), color-stop(100%, #cbcbcb));
  background: -webkit-linear-gradient(top, #888888 0%, #cbcbcb 100%);
  background: -o-linear-gradient(top, #888888 0%, #cbcbcb 100%);
  background: -ms-linear-gradient(top, #888888 0%, #cbcbcb 100%);
  background: linear-gradient(to bottom, #888888 0%, #cbcbcb 100%);
  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#888888', endColorstr='#cbcbcb', GradientType=0);
}
body div#wrapper ul.accordion li:not(.current) div.accordion-content {
  display: none;
}

redpajama_set_name: RedPajamaGithub


text:
<?php

namespace PhpFirebase\Entities;

interface EntityInterface
{
    public function toArray();

    public function toJson();

    public static function fromJson($string);
}


text:
using System;
using System.Diagnostics;
using System.Drawing;
using System.Windows.Forms;

namespace NSpecRunner.GUI.Framework
{
    public static class Extentions
    {
        [DebuggerNonUserCode]
        public static void InvokeAction(this Form form, Action action)
        {
            if (form.InvokeRequired)
            {
                form.Invoke(action);
            }
            else
            {
                action();
            }
        }

        [DebuggerNonUserCode]
        public static void SetTitle(this Form form, string title = null)
        {
            if (!string.IsNullOrWhiteSpace(title)) form.Text = string.Format("{0} - {1}", title, ApplicationConstants.APPLICATION_NAME);
            else form.Text = ApplicationConstants.APPLICATION_NAME;

        }

        [DebuggerNonUserCode]
        public static void AppendText(this RichTextBox box, string text, Color color)
        {
            box.SelectionStart = box.TextLength;
            box.SelectionLength = 0;

            box.SelectionColor = color;
            box.AppendText(text);
            box.SelectionColor = box.ForeColor;
        }

        [DebuggerNonUserCode]
        public static void AppendLine(this RichTextBox box, int space, string text, Color color)
        {
            box.AppendText("\n");
            box.SelectionStart = box.TextLength;
            box.SelectionLength = 0;

            box.SelectionColor = color;

            box.AppendText(text.PadLeft(space + text.Length, ' '));
            box.SelectionColor = box.ForeColor;
        }
    }
}


text:
define( [ "jquery", "./listview", "./forms/textinput" ], function( jQuery ) {
//>>excludeEnd("jqmBuildExclude");
(function( $, undefined ) {

$.mobile.listview.prototype.options.filter = false;
$.mobile.listview.prototype.options.filterPlaceholder = "";
$.mobile.listview.prototype.options.filterTheme = "c";
// TODO rename callback/deprecate and default to the item itself as the first argument
var defaultFilterCallback = function( text, searchValue, item ) {
		return text.toString().toLowerCase().indexOf( searchValue ) === -1;
	};

$.mobile.listview.prototype.options.filterCallback = defaultFilterCallback;

$.mobile.$document.delegate( ":jqmData(role='listview')", "listviewcreate", function() {

	var list = $( this ),
		listview = list.data( "listview" );

	if ( !listview.options.filter ) {
		return;
	}

	var wrapper = $( "<form>", {
			"class": "ui-listview-filter ui-bar-" + listview.options.filterTheme,
			"role": "search"
		}),
		search = $( "<input>", {
			placeholder: listview.options.filterPlaceholder
		})
		.attr( "data-" + $.mobile.ns + "type", "search" )
		.jqmData( "lastval", "" )
		.bind( "keyup change", function() {

			var $this = $( this ),
				val = this.value.toLowerCase(),
				listItems = null,
				lastval = $this.jqmData( "lastval" ) + "",
				childItems = false,
				itemtext = "",
				item,
				// Check if a custom filter callback applies
				isCustomFilterCallback = listview.options.filterCallback !== defaultFilterCallback;

			listview._trigger( "beforefilter", "beforefilter", { input: this } );

			// Change val as lastval for next execution
			$this.jqmData( "lastval" , val );
			if ( isCustomFilterCallback || val.length < lastval.length || val.indexOf( lastval ) !== 0 ) {

				// Custom filter callback applies or removed chars or pasted something totally different, check all items
				listItems = list.children();
			} else {

				// Only chars added, not removed, only use visible subset
				listItems = list.children( ":not(.ui-screen-hidden)" );
			}

			if ( val ) {

				// This handles hiding regular rows without the text we search for
				// and any list dividers without regular rows shown under it

				for ( var i = listItems.length - 1; i >= 0; i-- ) {
					item = $( listItems[ i ] );
					itemtext =  $.mobile.getAttrFixed( item[0], "data-" + $.mobile.ns + "filtertext" ) || item.text();

					if ( item.is( "li:jqmData(role=list-divider)" ) ) {

						item.toggleClass( "ui-filter-hidequeue" , !childItems );

						// New bucket!
						childItems = false;

					} else if ( listview.options.filterCallback( itemtext, val, item ) ) {

						//mark to be hidden
						item.toggleClass( "ui-filter-hidequeue" , true );
					} else {

						// There's a shown item in the bucket
						childItems = true;
					}
				}

				// Show items, not marked to be hidden
				listItems
					.filter( ":not(.ui-filter-hidequeue)" )
					.toggleClass( "ui-screen-hidden", false );

				// Hide items, marked to be hidden
				listItems
					.filter( ".ui-filter-hidequeue" )
					.toggleClass( "ui-screen-hidden", true )
					.toggleClass( "ui-filter-hidequeue", false );

			} else {

				//filtervalue is empty => show all
				listItems.toggleClass( "ui-screen-hidden", false );
			}
			listview._refreshCorners();
		})
		.appendTo( wrapper )
		.textinput();

	if ( listview.options.inset ) {
		wrapper.addClass( "ui-listview-filter-inset" );
	}

	wrapper.bind( "submit", function() {
		return false;
	})
	.insertBefore( list );
});

})( jQuery );
//>>excludeStart("jqmBuildExclude", pragmas.jqmBuildExclude);
});
//>>excludeEnd("jqmBuildExclude");


text:
package weibo4j.examples.location;

import weibo4j.Location;
import weibo4j.examples.oauth2.Log;
import weibo4j.model.Poisition;
import weibo4j.model.WeiboException;

import java.util.List;

public class SearchPoisByLocation {

    public static void main(String[] args) {
        String access_token = args[0];
        String q = args[1];
        Location l = new Location(access_token);
        try {
            List<Poisition> list = l.searchPoisByLocationByQ(q);
            for (Poisition p : list) {
                Log.logInfo(p.toString());
            }
        }
        catch (WeiboException e) {
            e.printStackTrace();
        }

    }

}


text:
/* Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.activiti.engine.impl.db;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.activiti.engine.impl.cfg.IdGenerator;
import org.activiti.engine.impl.interceptor.Session;
import org.activiti.engine.impl.interceptor.SessionFactory;
import org.activiti.engine.impl.persistence.entity.EventLogEntryEntity;
import org.apache.ibatis.session.SqlSessionFactory;

/**
 * @author Tom Baeyens
 */
public class DbSqlSessionFactory implements SessionFactory {

    protected static final Map<String, Map<String, String>> databaseSpecificStatements = new HashMap<>();

    public static final Map<String, String> databaseSpecificLimitBeforeStatements = new HashMap<>();
    public static final Map<String, String> databaseSpecificLimitAfterStatements = new HashMap<>();
    public static final Map<String, String> databaseSpecificLimitBetweenStatements = new HashMap<>();
    public static final Map<String, String> databaseSpecificOrderByStatements = new HashMap<>();
    public static final Map<String, String> databaseOuterJoinLimitBetweenStatements = new HashMap<>();
    public static final Map<String, String> databaseSpecificLimitBeforeNativeQueryStatements = new HashMap<>();

    static {

        String defaultOrderBy = " order by ${orderByColumns} ";

        // h2
        databaseSpecificLimitBeforeStatements.put("h2", "");
        databaseSpecificLimitAfterStatements.put("h2", "LIMIT #{maxResults} OFFSET #{firstResult}");
        databaseSpecificLimitBetweenStatements.put("h2", "");
        databaseOuterJoinLimitBetweenStatements.put("h2", "");
        databaseSpecificOrderByStatements.put("h2", defaultOrderBy);

        // hsql
        databaseSpecificLimitBeforeStatements.put("hsql", "");
        databaseSpecificLimitAfterStatements.put("hsql", "LIMIT #{maxResults} OFFSET #{firstResult}");
        databaseSpecificLimitBetweenStatements.put("hsql", "");
        databaseOuterJoinLimitBetweenStatements.put("hsql", "");
        databaseSpecificOrderByStatements.put("hsql", defaultOrderBy);

        // mysql specific
        databaseSpecificLimitBeforeStatements.put("mysql", "");
        databaseSpecificLimitAfterStatements.put("mysql", "LIMIT #{maxResults} OFFSET #{firstResult}");
        databaseSpecificLimitBetweenStatements.put("mysql", "");
        databaseOuterJoinLimitBetweenStatements.put("mysql", "");
        databaseSpecificOrderByStatements.put("mysql", defaultOrderBy);
        addDatabaseSpecificStatement("mysql", "selectProcessDefinitionsByQueryCriteria", "selectProcessDefinitionsByQueryCriteria_mysql");
        addDatabaseSpecificStatement("mysql", "selectProcessDefinitionCountByQueryCriteria", "selectProcessDefinitionCountByQueryCriteria_mysql");
        addDatabaseSpecificStatement("mysql", "selectDeploymentsByQueryCriteria", "selectDeploymentsByQueryCriteria_mysql");
        addDatabaseSpecificStatement("mysql", "selectDeploymentCountByQueryCriteria", "selectDeploymentCountByQueryCriteria_mysql");
        addDatabaseSpecificStatement("mysql", "selectModelCountByQueryCriteria", "selectModelCountByQueryCriteria_mysql");
        addDatabaseSpecificStatement("mysql", "updateExecutionTenantIdForDeployment", "updateExecutionTenantIdForDeployment_mysql");
        addDatabaseSpecificStatement("mysql", "updateTaskTenantIdForDeployment", "updateTaskTenantIdForDeployment_mysql");
        addDatabaseSpecificStatement("mysql", "updateJobTenantIdForDeployment", "updateJobTenantIdForDeployment_mysql");
        addDatabaseSpecificStatement("mysql", "updateTimerJobTenantIdForDeployment", "updateTimerJobTenantIdForDeployment_mysql");
        addDatabaseSpecificStatement("mysql", "updateSuspendedJobTenantIdForDeployment", "updateSuspendedJobTenantIdForDeployment_mysql");
        addDatabaseSpecificStatement("mysql", "updateDeadLetterJobTenantIdForDeployment", "updateDeadLetterJobTenantIdForDeployment_mysql");

        // postgres specific
        databaseSpecificLimitBeforeStatements.put("postgres", "");
        databaseSpecificLimitAfterStatements.put("postgres", "LIMIT #{maxResults} OFFSET #{firstResult}");
        databaseSpecificLimitBetweenStatements.put("postgres", "");
        databaseOuterJoinLimitBetweenStatements.put("postgres", "");
        databaseSpecificOrderByStatements.put("postgres", defaultOrderBy);
        addDatabaseSpecificStatement("postgres", "insertByteArray", "insertByteArray_postgres");
        addDatabaseSpecificStatement("postgres", "bulkInsertByteArray", "bulkInsertByteArray_postgres");
        addDatabaseSpecificStatement("postgres", "updateByteArray", "updateByteArray_postgres");
        addDatabaseSpecificStatement("postgres", "selectByteArray", "selectByteArray_postgres");
        addDatabaseSpecificStatement("postgres", "selectResourceByDeploymentIdAndResourceName", "selectResourceByDeploymentIdAndResourceName_postgres");
        addDatabaseSpecificStatement("postgres", "selectResourcesByDeploymentId", "selectResourcesByDeploymentId_postgres");
        addDatabaseSpecificStatement("postgres", "insertComment", "insertComment_postgres");
        addDatabaseSpecificStatement("postgres", "bulkInsertComment", "bulkInsertComment_postgres");
        addDatabaseSpecificStatement("postgres", "selectComment", "selectComment_postgres");
        addDatabaseSpecificStatement("postgres", "selectCommentsByTaskId", "selectCommentsByTaskId_postgres");
        addDatabaseSpecificStatement("postgres", "selectCommentsByProcessInstanceId", "selectCommentsByProcessInstanceId_postgres");
        addDatabaseSpecificStatement("postgres", "selectCommentsByProcessInstanceIdAndType", "selectCommentsByProcessInstanceIdAndType_postgres");
        addDatabaseSpecificStatement("postgres", "selectCommentsByType", "selectCommentsByType_postgres");
        addDatabaseSpecificStatement("postgres", "selectCommentsByTaskIdAndType", "selectCommentsByTaskIdAndType_postgres");
        addDatabaseSpecificStatement("postgres", "selectEventsByTaskId", "selectEventsByTaskId_postgres");
        addDatabaseSpecificStatement("postgres", "insertEventLogEntry", "insertEventLogEntry_postgres");
        addDatabaseSpecificStatement("postgres", "bulkInsertEventLogEntry", "bulkInsertEventLogEntry_postgres");
        addDatabaseSpecificStatement("postgres", "selectAllEventLogEntries", "selectAllEventLogEntries_postgres");
        addDatabaseSpecificStatement("postgres", "selectEventLogEntries", "selectEventLogEntries_postgres");
        addDatabaseSpecificStatement("postgres", "selectEventLogEntriesByProcessInstanceId", "selectEventLogEntriesByProcessInstanceId_postgres");

        // oracle
        databaseSpecificLimitBeforeStatements.put("oracle", "select * from ( select a.*, ROWNUM rnum from (");
        databaseSpecificLimitAfterStatements.put("oracle", "  ) a where ROWNUM < #{lastRow}) where rnum  >= #{firstRow}");
        databaseSpecificLimitBetweenStatements.put("oracle", "");
        databaseOuterJoinLimitBetweenStatements.put("oracle", "");
        databaseSpecificOrderByStatements.put("oracle", defaultOrderBy);
        addDatabaseSpecificStatement("oracle", "selectExclusiveJobsToExecute", "selectExclusiveJobsToExecute_integerBoolean");
        addDatabaseSpecificStatement("oracle", "selectUnlockedTimersByDuedate", "selectUnlockedTimersByDuedate_oracle");
        addDatabaseSpecificStatement("oracle", "insertEventLogEntry", "insertEventLogEntry_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertVariableInstance", "bulkInsertVariableInstance_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertTask", "bulkInsertTask_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertResource", "bulkInsertResource_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertProperty", "bulkInsertProperty_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertProcessDefinition", "bulkInsertProcessDefinition_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertModel", "bulkInsertModel_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertTimer", "bulkInsertTimer_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertMessage", "bulkInsertMessage_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertIdentityLink", "bulkInsertIdentityLink_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertHistoricVariableInstance", "bulkInsertHistoricVariableInstance_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertHistoricTaskInstance", "bulkInsertHistoricTaskInstance_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertHistoricProcessInstance", "bulkInsertHistoricProcessInstance_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertHistoricIdentityLink", "bulkInsertHistoricIdentityLink_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertHistoricDetailVariableInstanceUpdate", "bulkInsertHistoricDetailVariableInstanceUpdate_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertHistoricFormProperty", "bulkInsertHistoricFormProperty_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertHistoricActivityInstance", "bulkInsertHistoricActivityInstance_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertExecution", "bulkInsertExecution_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertMessageEventSubscription", "bulkInsertMessageEventSubscription_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertSignalEventSubscription", "bulkInsertSignalEventSubscription_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertCompensateEventSubscription", "bulkInsertCompensateEventSubscription_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertEventLogEntry", "bulkInsertEventLogEntry_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertDeployment", "bulkInsertDeployment_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertComment", "bulkInsertComment_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertByteArray", "bulkInsertByteArray_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertEventLogEntry", "bulkInsertEventLogEntry_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertDeployment", "bulkInsertDeployment_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertComment", "bulkInsertComment_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertAttachment", "bulkInsertAttachment_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertJob", "bulkInsertJob_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertTimerJob", "bulkInsertTimerJob_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertSuspendedJob", "bulkInsertSuspendedJob_oracle");
        addDatabaseSpecificStatement("oracle", "bulkInsertDeadLetterJob", "bulkInsertDeadLetterJob_oracle");

        // db2
        databaseSpecificLimitBeforeStatements.put("db2", "SELECT SUB.* FROM (");
        databaseSpecificLimitAfterStatements.put("db2", ")RES ) SUB WHERE SUB.rnk >= #{firstRow} AND SUB.rnk < #{lastRow}");
        databaseSpecificLimitBetweenStatements.put("db2", ", row_number() over (ORDER BY ${orderByColumns}) rnk FROM ( select distinct RES.* ");
        databaseOuterJoinLimitBetweenStatements.put("db2", ", row_number() over (ORDER BY ${mssqlOrDB2OrderBy}) rnk FROM ( select distinct ");
        databaseSpecificOrderByStatements.put("db2", "");
        databaseSpecificLimitBeforeNativeQueryStatements.put("db2", "SELECT SUB.* FROM ( select RES.* , row_number() over (ORDER BY ${orderByColumns}) rnk FROM (");
        addDatabaseSpecificStatement("db2", "selectExclusiveJobsToExecute", "selectExclusiveJobsToExecute_integerBoolean");
        addDatabaseSpecificStatement("db2", "selectExecutionByNativeQuery", "selectExecutionByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("db2", "selectHistoricActivityInstanceByNativeQuery", "selectHistoricActivityInstanceByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("db2", "selectHistoricProcessInstanceByNativeQuery", "selectHistoricProcessInstanceByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("db2", "selectHistoricTaskInstanceByNativeQuery", "selectHistoricTaskInstanceByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("db2", "selectTaskByNativeQuery", "selectTaskByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("db2", "selectProcessDefinitionByNativeQuery", "selectProcessDefinitionByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("db2", "selectDeploymentByNativeQuery", "selectDeploymentByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("db2", "selectModelByNativeQuery", "selectModelByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("db2", "selectHistoricDetailByNativeQuery", "selectHistoricDetailByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("db2", "selectHistoricVariableInstanceByNativeQuery", "selectHistoricVariableInstanceByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("db2", "selectTaskWithVariablesByQueryCriteria", "selectTaskWithVariablesByQueryCriteria_mssql_or_db2");
        addDatabaseSpecificStatement("db2", "selectProcessInstanceWithVariablesByQueryCriteria", "selectProcessInstanceWithVariablesByQueryCriteria_mssql_or_db2");
        addDatabaseSpecificStatement("db2", "selectHistoricProcessInstancesWithVariablesByQueryCriteria", "selectHistoricProcessInstancesWithVariablesByQueryCriteria_mssql_or_db2");
        addDatabaseSpecificStatement("db2", "selectHistoricTaskInstancesWithVariablesByQueryCriteria", "selectHistoricTaskInstancesWithVariablesByQueryCriteria_mssql_or_db2");

        // mssql
        databaseSpecificLimitBeforeStatements.put("mssql", "SELECT SUB.* FROM (");
        databaseSpecificLimitAfterStatements.put("mssql", ")RES ) SUB WHERE SUB.rnk >= #{firstRow} AND SUB.rnk < #{lastRow}");
        databaseSpecificLimitBetweenStatements.put("mssql", ", row_number() over (ORDER BY ${orderByColumns}) rnk FROM ( select distinct RES.* ");
        databaseOuterJoinLimitBetweenStatements.put("mssql", ", row_number() over (ORDER BY ${mssqlOrDB2OrderBy}) rnk FROM ( select distinct ");
        databaseSpecificOrderByStatements.put("mssql", "");
        databaseSpecificLimitBeforeNativeQueryStatements.put("mssql", "SELECT SUB.* FROM ( select RES.* , row_number() over (ORDER BY ${orderByColumns}) rnk FROM (");
        addDatabaseSpecificStatement("mssql", "selectExclusiveJobsToExecute", "selectExclusiveJobsToExecute_integerBoolean");
        addDatabaseSpecificStatement("mssql", "selectExecutionByNativeQuery", "selectExecutionByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("mssql", "selectHistoricActivityInstanceByNativeQuery", "selectHistoricActivityInstanceByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("mssql", "selectHistoricProcessInstanceByNativeQuery", "selectHistoricProcessInstanceByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("mssql", "selectHistoricTaskInstanceByNativeQuery", "selectHistoricTaskInstanceByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("mssql", "selectTaskByNativeQuery", "selectTaskByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("mssql", "selectProcessDefinitionByNativeQuery", "selectProcessDefinitionByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("mssql", "selectDeploymentByNativeQuery", "selectDeploymentByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("mssql", "selectModelByNativeQuery", "selectModelByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("mssql", "selectHistoricDetailByNativeQuery", "selectHistoricDetailByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("mssql", "selectHistoricVariableInstanceByNativeQuery", "selectHistoricVariableInstanceByNativeQuery_mssql_or_db2");
        addDatabaseSpecificStatement("mssql", "selectTaskWithVariablesByQueryCriteria", "selectTaskWithVariablesByQueryCriteria_mssql_or_db2");
        addDatabaseSpecificStatement("mssql", "selectProcessInstanceWithVariablesByQueryCriteria", "selectProcessInstanceWithVariablesByQueryCriteria_mssql_or_db2");
        addDatabaseSpecificStatement("mssql", "selectHistoricProcessInstancesWithVariablesByQueryCriteria", "selectHistoricProcessInstancesWithVariablesByQueryCriteria_mssql_or_db2");
        addDatabaseSpecificStatement("mssql", "selectHistoricTaskInstancesWithVariablesByQueryCriteria", "selectHistoricTaskInstancesWithVariablesByQueryCriteria_mssql_or_db2");
    }

    /**
     * A map {class, boolean}, to indicate whether or not a certain {@link PersistentObject} class can be bulk inserted.
     */
    protected static Map<Class<? extends PersistentObject>, Boolean> bulkInsertableMap;

    protected String databaseType;
    protected String databaseTablePrefix = "";
    private boolean tablePrefixIsSchema;

    protected String databaseCatalog;
    /**
     * In some situations you want to set the schema to use for table checks / generation if the database metadata doesn't return that correctly, see https://activiti.atlassian.net/browse/ACT-1220,
     * https://activiti.atlassian.net/browse/ACT-1062
     */
    protected String databaseSchema;
    protected SqlSessionFactory sqlSessionFactory;
    protected IdGenerator idGenerator;
    protected Map<String, String> statementMappings;
    protected Map<Class<?>, String> insertStatements = new ConcurrentHashMap<>();
    protected Map<Class<?>, String> bulkInsertStatements = new ConcurrentHashMap<>();
    protected Map<Class<?>, String> updateStatements = new ConcurrentHashMap<>();
    protected Map<Class<?>, String> deleteStatements = new ConcurrentHashMap<>();
    protected Map<Class<?>, String> bulkDeleteStatements = new ConcurrentHashMap<>();
    protected Map<Class<?>, String> selectStatements = new ConcurrentHashMap<>();
    protected boolean isDbHistoryUsed = true;
    protected int maxNrOfStatementsInBulkInsert = 100;

    @Override
    public Class<?> getSessionType() {
        return DbSqlSession.class;
    }

    @Override
    public Session openSession() {
        return new DbSqlSession(this);
    }

    // insert, update and delete statements /////////////////////////////////////

    public String getInsertStatement(PersistentObject object) {
        return getStatement(object.getClass(), insertStatements, "insert");
    }

    public String getInsertStatement(Class<? extends PersistentObject> clazz) {
        return getStatement(clazz, insertStatements, "insert");
    }

    public String getBulkInsertStatement(Class clazz) {
        return getStatement(clazz, bulkInsertStatements, "bulkInsert");
    }

    public String getUpdateStatement(PersistentObject object) {
        return getStatement(object.getClass(), updateStatements, "update");
    }

    public String getDeleteStatement(Class<?> persistentObjectClass) {
        return getStatement(persistentObjectClass, deleteStatements, "delete");
    }

    public String getBulkDeleteStatement(Class<?> persistentObjectClass) {
        return getStatement(persistentObjectClass, bulkDeleteStatements, "bulkDelete");
    }

    public String getSelectStatement(Class<?> persistentObjectClass) {
        return getStatement(persistentObjectClass, selectStatements, "select");
    }

    private String getStatement(Class<?> persistentObjectClass, Map<Class<?>, String> cachedStatements, String prefix) {
        String statement = cachedStatements.get(persistentObjectClass);
        if (statement != null) {
            return statement;
        }
        statement = prefix + persistentObjectClass.getSimpleName();
        statement = statement.substring(0, statement.length() - 6); // removing 'entity'
        cachedStatements.put(persistentObjectClass, statement);
        return statement;
    }

    // db specific mappings /////////////////////////////////////////////////////

    protected static void addDatabaseSpecificStatement(String databaseType, String activitiStatement, String ibatisStatement) {
        Map<String, String> specificStatements = databaseSpecificStatements.get(databaseType);
        if (specificStatements == null) {
            specificStatements = new HashMap<>();
            databaseSpecificStatements.put(databaseType, specificStatements);
        }
        specificStatements.put(activitiStatement, ibatisStatement);
    }

    public String mapStatement(String statement) {
        if (statementMappings == null) {
            return statement;
        }
        String mappedStatement = statementMappings.get(statement);
        return (mappedStatement != null ? mappedStatement : statement);
    }

    // customized getters and setters ///////////////////////////////////////////

    public void setDatabaseType(String databaseType) {
        this.databaseType = databaseType;
        this.statementMappings = databaseSpecificStatements.get(databaseType);
    }

    public void setBulkInsertEnabled(boolean isBulkInsertEnabled, String databaseType) {
        // If false, just keep don't initialize the map. Memory saved.
        if (isBulkInsertEnabled) {
            initBulkInsertEnabledMap(databaseType);
        }
    }

    protected void initBulkInsertEnabledMap(String databaseType) {
        bulkInsertableMap = new HashMap<>();

        for (Class<? extends PersistentObject> clazz : EntityDependencyOrder.INSERT_ORDER) {
            bulkInsertableMap.put(clazz, Boolean.TRUE);
        }

        // Only Oracle is making a fuss in one specific case right now
        if ("oracle".equals(databaseType)) {
            bulkInsertableMap.put(EventLogEntryEntity.class, Boolean.FALSE);
        }
    }

    public Boolean isBulkInsertable(Class<? extends PersistentObject> persistentObjectClass) {
        return bulkInsertableMap != null && bulkInsertableMap.containsKey(persistentObjectClass) && bulkInsertableMap.get(persistentObjectClass);
    }

    // getters and setters //////////////////////////////////////////////////////

    public SqlSessionFactory getSqlSessionFactory() {
        return sqlSessionFactory;
    }

    public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
        this.sqlSessionFactory = sqlSessionFactory;
    }

    public IdGenerator getIdGenerator() {
        return idGenerator;
    }

    public void setIdGenerator(IdGenerator idGenerator) {
        this.idGenerator = idGenerator;
    }

    public String getDatabaseType() {
        return databaseType;
    }

    public Map<String, String> getStatementMappings() {
        return statementMappings;
    }

    public void setStatementMappings(Map<String, String> statementMappings) {
        this.statementMappings = statementMappings;
    }

    public Map<Class<?>, String> getInsertStatements() {
        return insertStatements;
    }

    public void setInsertStatements(Map<Class<?>, String> insertStatements) {
        this.insertStatements = insertStatements;
    }

    public Map<Class<?>, String> getBulkInsertStatements() {
        return bulkInsertStatements;
    }

    public void setBulkInsertStatements(Map<Class<?>, String> bulkInsertStatements) {
        this.bulkInsertStatements = bulkInsertStatements;
    }

    public Map<Class<?>, String> getUpdateStatements() {
        return updateStatements;
    }

    public void setUpdateStatements(Map<Class<?>, String> updateStatements) {
        this.updateStatements = updateStatements;
    }

    public Map<Class<?>, String> getDeleteStatements() {
        return deleteStatements;
    }

    public void setDeleteStatements(Map<Class<?>, String> deleteStatements) {
        this.deleteStatements = deleteStatements;
    }

    public Map<Class<?>, String> getBulkDeleteStatements() {
        return bulkDeleteStatements;
    }

    public void setBulkDeleteStatements(Map<Class<?>, String> bulkDeleteStatements) {
        this.bulkDeleteStatements = bulkDeleteStatements;
    }

    public Map<Class<?>, String> getSelectStatements() {
        return selectStatements;
    }

    public void setSelectStatements(Map<Class<?>, String> selectStatements) {
        this.selectStatements = selectStatements;
    }

    public boolean isDbHistoryUsed() {
        return isDbHistoryUsed;
    }

    public void setDbHistoryUsed(boolean isDbHistoryUsed) {
        this.isDbHistoryUsed = isDbHistoryUsed;
    }

    public void setDatabaseTablePrefix(String databaseTablePrefix) {
        this.databaseTablePrefix = databaseTablePrefix;
    }

    public String getDatabaseTablePrefix() {
        return databaseTablePrefix;
    }

    public String getDatabaseCatalog() {
        return databaseCatalog;
    }

    public void setDatabaseCatalog(String databaseCatalog) {
        this.databaseCatalog = databaseCatalog;
    }

    public String getDatabaseSchema() {
        return databaseSchema;
    }

    public void setDatabaseSchema(String databaseSchema) {
        this.databaseSchema = databaseSchema;
    }

    public void setTablePrefixIsSchema(boolean tablePrefixIsSchema) {
        this.tablePrefixIsSchema = tablePrefixIsSchema;
    }

    public boolean isTablePrefixIsSchema() {
        return tablePrefixIsSchema;
    }

    public int getMaxNrOfStatementsInBulkInsert() {
        return maxNrOfStatementsInBulkInsert;
    }

    public void setMaxNrOfStatementsInBulkInsert(int maxNrOfStatementsInBulkInsert) {
        this.maxNrOfStatementsInBulkInsert = maxNrOfStatementsInBulkInsert;
    }

}


text:
package com.deleidos.rtws.commons.cloud.platform.aws;

/**
 * Repository of AWS Codes.
 */
public class AwsStateCodes {

	/** Constructor. */
	protected AwsStateCodes() { }

	/** Code for an instance starting. */
	public static final int INSTANCE_CODE_STARTING = 16;

	/** Code for an instance stopped. */
	public static final int INSTANCE_CODE_STOPPED = 80;

	/** Code for an instance stopping. */
	public static final int INSTANCE_CODE_STOPPING = 16;

	/** Code for an instance termination. */
	public static final int INSTANCE_CODE_TERMINATED = 48;

}


text:
package com.fedevela.core.lgs.destruction.pojos;

/**
 * Created by fvelazquez on 28/03/14.
 */
import java.io.Serializable;
import java.math.BigInteger;
import java.util.Date;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.JoinColumn;
import javax.persistence.JoinColumns;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Entity
@Table(name = "LGS_DESTRUCTION_PLAN_CONFIG", catalog = "", schema = "PROD")
@NamedQueries({
        @NamedQuery(name = "LgsDestructionPlanConfig.findAll", query = "SELECT l FROM LgsDestructionPlanConfig l"),
        @NamedQuery(name = "LgsDestructionPlanConfig.findByIdPlan", query = "SELECT l FROM LgsDestructionPlanConfig l WHERE l.lgsDestructionPlanConfigPK.idPlan = :idPlan"),
        @NamedQuery(name = "LgsDestructionPlanConfig.findByIdCustomer", query = "SELECT l FROM LgsDestructionPlanConfig l WHERE l.lgsDestructionPlanConfigPK.idCustomer = :idCustomer"),
        @NamedQuery(name = "LgsDestructionPlanConfig.findByIdPeriod", query = "SELECT l FROM LgsDestructionPlanConfig l WHERE l.lgsDestructionPlanConfigPK.idPeriod = :idPeriod"),
        @NamedQuery(name = "LgsDestructionPlanConfig.findByStartDate", query = "SELECT l FROM LgsDestructionPlanConfig l WHERE l.startDate = :startDate"),
        @NamedQuery(name = "LgsDestructionPlanConfig.findByEndDate", query = "SELECT l FROM LgsDestructionPlanConfig l WHERE l.endDate = :endDate"),
        @NamedQuery(name = "LgsDestructionPlanConfig.findByAuthorizedStartDate", query = "SELECT l FROM LgsDestructionPlanConfig l WHERE l.authorizedStartDate = :authorizedStartDate"),
        @NamedQuery(name = "LgsDestructionPlanConfig.findByAuthorizedEndDate", query = "SELECT l FROM LgsDestructionPlanConfig l WHERE l.authorizedEndDate = :authorizedEndDate"),
        @NamedQuery(name = "LgsDestructionPlanConfig.findByCustAuthorizedStartDate", query = "SELECT l FROM LgsDestructionPlanConfig l WHERE l.custAuthorizedStartDate = :custAuthorizedStartDate"),
        @NamedQuery(name = "LgsDestructionPlanConfig.findByCustAuthorizedEndDate", query = "SELECT l FROM LgsDestructionPlanConfig l WHERE l.custAuthorizedEndDate = :custAuthorizedEndDate")})
public class LgsDestructionPlanConfig implements Serializable {
    private static final long serialVersionUID = 1L;
    @EmbeddedId
    protected LgsDestructionPlanConfigPK lgsDestructionPlanConfigPK;
    @Basic(optional = false)
    @Column(name = "START_DATE")
    @Temporal(TemporalType.DATE)
    private Date startDate;
    @Basic(optional = false)
    @Column(name = "END_DATE")
    @Temporal(TemporalType.DATE)
    private Date endDate;
    @Basic(optional = false)
    @Column(name = "AUTHORIZED_START_DATE")
    @Temporal(TemporalType.DATE)
    private Date authorizedStartDate;
    @Basic(optional = false)
    @Column(name = "AUTHORIZED_END_DATE")
    @Temporal(TemporalType.DATE)
    private Date authorizedEndDate;
    @Basic(optional = false)
    @Column(name = "CUST_AUTHORIZED_START_DATE")
    @Temporal(TemporalType.DATE)
    private Date custAuthorizedStartDate;
    @Basic(optional = false)
    @Column(name = "CUST_AUTHORIZED_END_DATE")
    @Temporal(TemporalType.DATE)
    private Date custAuthorizedEndDate;
    @JoinColumn(name = "ID_PERIOD", referencedColumnName = "ID_PERIOD", insertable = false, updatable = false)
    @ManyToOne(optional = false)
    private LgsPeriods lgsPeriods;
    @JoinColumns({
            @JoinColumn(name = "ID_PLAN", referencedColumnName = "ID_PLAN", insertable = false, updatable = false),
            @JoinColumn(name = "ID_CUSTOMER", referencedColumnName = "ID_CUSTOMER", insertable = false, updatable = false)})
    @ManyToOne(optional = false)
    private LgsDestructionsPlan lgsDestructionsPlan;

    public LgsDestructionPlanConfig() {
    }

    public LgsDestructionPlanConfig(LgsDestructionPlanConfigPK lgsDestructionPlanConfigPK) {
        this.lgsDestructionPlanConfigPK = lgsDestructionPlanConfigPK;
    }

    public LgsDestructionPlanConfig(LgsDestructionPlanConfigPK lgsDestructionPlanConfigPK, Date startDate, Date endDate, Date authorizedStartDate, Date authorizedEndDate, Date custAuthorizedStartDate, Date custAuthorizedEndDate) {
        this.lgsDestructionPlanConfigPK = lgsDestructionPlanConfigPK;
        this.startDate = startDate;
        this.endDate = endDate;
        this.authorizedStartDate = authorizedStartDate;
        this.authorizedEndDate = authorizedEndDate;
        this.custAuthorizedStartDate = custAuthorizedStartDate;
        this.custAuthorizedEndDate = custAuthorizedEndDate;
    }

    public LgsDestructionPlanConfig(BigInteger idPlan, short idCustomer, BigInteger idPeriod) {
        this.lgsDestructionPlanConfigPK = new LgsDestructionPlanConfigPK(idPlan, idCustomer, idPeriod);
    }

    public LgsDestructionPlanConfigPK getLgsDestructionPlanConfigPK() {
        return lgsDestructionPlanConfigPK;
    }

    public void setLgsDestructionPlanConfigPK(LgsDestructionPlanConfigPK lgsDestructionPlanConfigPK) {
        this.lgsDestructionPlanConfigPK = lgsDestructionPlanConfigPK;
    }

    public Date getStartDate() {
        return startDate;
    }

    public void setStartDate(Date startDate) {
        this.startDate = startDate;
    }

    public Date getEndDate() {
        return endDate;
    }

    public void setEndDate(Date endDate) {
        this.endDate = endDate;
    }

    public Date getAuthorizedStartDate() {
        return authorizedStartDate;
    }

    public void setAuthorizedStartDate(Date authorizedStartDate) {
        this.authorizedStartDate = authorizedStartDate;
    }

    public Date getAuthorizedEndDate() {
        return authorizedEndDate;
    }

    public void setAuthorizedEndDate(Date authorizedEndDate) {
        this.authorizedEndDate = authorizedEndDate;
    }

    public Date getCustAuthorizedStartDate() {
        return custAuthorizedStartDate;
    }

    public void setCustAuthorizedStartDate(Date custAuthorizedStartDate) {
        this.custAuthorizedStartDate = custAuthorizedStartDate;
    }

    public Date getCustAuthorizedEndDate() {
        return custAuthorizedEndDate;
    }

    public void setCustAuthorizedEndDate(Date custAuthorizedEndDate) {
        this.custAuthorizedEndDate = custAuthorizedEndDate;
    }

    public LgsPeriods getLgsPeriods() {
        return lgsPeriods;
    }

    public void setLgsPeriods(LgsPeriods lgsPeriods) {
        this.lgsPeriods = lgsPeriods;
    }

    public LgsDestructionsPlan getLgsDestructionsPlan() {
        return lgsDestructionsPlan;
    }

    public void setLgsDestructionsPlan(LgsDestructionsPlan lgsDestructionsPlan) {
        this.lgsDestructionsPlan = lgsDestructionsPlan;
    }

    @Override
    public int hashCode() {
        int hash = 0;
        hash += (lgsDestructionPlanConfigPK != null ? lgsDestructionPlanConfigPK.hashCode() : 0);
        return hash;
    }

    @Override
    public boolean equals(Object object) {
        // TODO: Warning - this method won't work in the case the id fields are not set
        if (!(object instanceof LgsDestructionPlanConfig)) {
            return false;
        }
        LgsDestructionPlanConfig other = (LgsDestructionPlanConfig) object;
        if ((this.lgsDestructionPlanConfigPK == null && other.lgsDestructionPlanConfigPK != null) || (this.lgsDestructionPlanConfigPK != null && !this.lgsDestructionPlanConfigPK.equals(other.lgsDestructionPlanConfigPK))) {
            return false;
        }
        return true;
    }

    @Override
    public String toString() {
        return "com.adeadms.core.lgs.destruction.pojos.LgsDestructionPlanConfig[lgsDestructionPlanConfigPK=" + lgsDestructionPlanConfigPK + "]";
    }

}


text:
package de.tomgrill.gdxfacebook.desktop;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.utils.Array;
import com.badlogic.gdx.utils.ArrayMap;
import com.badlogic.gdx.utils.TimeUtils;
import de.tomgrill.gdxfacebook.core.*;
import de.tomgrill.gdxfacebook.core.utils.Utils;

import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URL;

public class DesktopGDXFacebook extends GDXFacebookBasic implements JXBrowserCallbackHandler {

    public DesktopGDXFacebook(GDXFacebookConfig config) {
        super(config);
    }

    @Override
    public void signIn(SignInMode mode, final Array<String> permissions, final GDXFacebookCallback<SignInResult> callback) {
        this.callback = callback;
        this.permissions = permissions;

        loadAccessToken();

        if (accessToken != null) {
            startSilentSignIn();
        } else {
            startGUISignIn();
        }

    }

    @Override
    public void showGameRequest(GDXFacebookGameRequest request, GDXFacebookCallback<GameRequestResult> callback) {
        gameRequest(request, callback);
    }

    @Override
    public void gameRequest(GDXFacebookGameRequest request, GDXFacebookCallback<GameRequestResult> callback) {
        Gdx.app.debug(GDXFacebookVars.LOG_TAG, "Game Request not supported on Desktop");
    }

    @Override
    protected void startGUISignIn() {
        if (accessToken == null) {
            JXBrowser.login(permissions, config, this);
            Gdx.app.debug(GDXFacebookVars.LOG_TAG, "Starting GUI sign in.");
        }
    }

    @Override
    public boolean isSignedIn() {
        return accessToken != null;
    }

    @Override
    public boolean isLoaded() {
        return true;
    }

    @Override
    public void handleURL(String url) {
        if (Utils.isValidErrorSignInURL(url)) {
            handleErrorSignIn(url);
        } else if (Utils.isValidSuccessfulSignInURL(url)) {
            handleSuccessSignIn(url);
        }
    }

    private void handleSuccessSignIn(String url) {
        try {
            URL urlObj = new URL(url);
            ArrayMap<String, String> params = Utils.parseQuery(urlObj.getRef());

            /** declare a 60 days expiration as default */
            long expiresInSecondsFromNow = 60 * 60 * 24;

            try {
                expiresInSecondsFromNow = Long.parseLong(params.get("expires_in"));
            } catch (NumberFormatException nfe) {
                Gdx.app.debug(GDXFacebookVars.LOG_TAG, "Given expires_in value is not a valid Long. 60 days expiration assumed and used.");
            }

            long expiresInMillisFromNow = expiresInSecondsFromNow * 1000L;
            long expiresInMillisTimestamp = expiresInMillisFromNow + TimeUtils.millis();

            accessToken = new GDXFacebookAccessToken(params.get("access_token"), expiresInMillisTimestamp);
            storeNewToken(accessToken);

            Gdx.app.debug(GDXFacebookVars.LOG_TAG, "Sign successful. User token: " + accessToken.getToken());

            callback.onSuccess(new SignInResult(accessToken, "Sign in successful."));

        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

    private void handleErrorSignIn(String url) {
        try {
            URL urlObj = new URL(url);

            String errorMessage = urlObj.getQuery();
            if (errorMessage != null) {
                Gdx.app.debug(GDXFacebookVars.LOG_TAG, "Error while trying to sign in: " + errorMessage);
                callback.onError(new GDXFacebookError(errorMessage));
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void handleCancel() {
        Gdx.app.debug(GDXFacebookVars.LOG_TAG, "Sign in has been fail");
        callback.onCancel();
    }

    @Override
    public void signOut(boolean keepSessionData) {
        super.signOut(keepSessionData);

        if(keepSessionData == SignOutMode.DELETE_SESSION_DATA) {
            deleteTokenData();
        }
    }
}


text:
package message

import "github.com/bwmarrin/discordgo"

//Embed ...
type Embed struct {
	*discordgo.MessageEmbed
}

// Constants for message embed character limits
const (
	EmbedLimitTitle       = 256
	EmbedLimitDescription = 2048
	EmbedLimitFieldValue  = 1024
	EmbedLimitFieldName   = 256
	EmbedLimitField       = 25
	EmbedLimitFooter      = 2048
	EmbedLimit            = 4000
)

//NewEmbed returns a new embed object
func NewEmbed() *Embed {
	return &Embed{&discordgo.MessageEmbed{}}
}

//SetTitle ...
func (e *Embed) SetTitle(name string) *Embed {
	e.Title = name
	return e
}

//SetDescription [desc]
func (e *Embed) SetDescription(description string) *Embed {
	if len(description) > 2048 {
		description = description[:2048]
	}
	e.Description = description
	return e
}

//AddField [name] [value]
func (e *Embed) AddField(name, value string) *Embed {
	if len(value) > 1024 {
		value = value[:1024]
	}

	if len(name) > 1024 {
		name = name[:1024]
	}

	e.Fields = append(e.Fields, &discordgo.MessageEmbedField{
		Name:  name,
		Value: value,
	})

	return e

}

//SetFooter [Text] [iconURL]
func (e *Embed) SetFooter(args ...string) *Embed {
	iconURL := ""
	text := ""
	proxyURL := ""

	switch {
	case len(args) > 2:
		proxyURL = args[2]
		fallthrough
	case len(args) > 1:
		iconURL = args[1]
		fallthrough
	case len(args) > 0:
		text = args[0]
	case len(args) == 0:
		return e
	}

	e.Footer = &discordgo.MessageEmbedFooter{
		IconURL:      iconURL,
		Text:         text,
		ProxyIconURL: proxyURL,
	}

	return e
}

//SetImage ...
func (e *Embed) SetImage(args ...string) *Embed {
	var URL string
	var proxyURL string

	if len(args) == 0 {
		return e
	}
	if len(args) > 0 {
		URL = args[0]
	}
	if len(args) > 1 {
		proxyURL = args[1]
	}
	e.Image = &discordgo.MessageEmbedImage{
		URL:      URL,
		ProxyURL: proxyURL,
	}
	return e
}

//SetThumbnail ...
func (e *Embed) SetThumbnail(args ...string) *Embed {
	var URL string
	var proxyURL string

	if len(args) == 0 {
		return e
	}
	if len(args) > 0 {
		URL = args[0]
	}
	if len(args) > 1 {
		proxyURL = args[1]
	}
	e.Thumbnail = &discordgo.MessageEmbedThumbnail{
		URL:      URL,
		ProxyURL: proxyURL,
	}
	return e
}

//SetAuthor ...
func (e *Embed) SetAuthor(args ...string) *Embed {
	var (
		name     string
		iconURL  string
		URL      string
		proxyURL string
	)

	if len(args) == 0 {
		return e
	}
	if len(args) > 0 {
		name = args[0]
	}
	if len(args) > 1 {
		iconURL = args[1]
	}
	if len(args) > 2 {
		URL = args[2]
	}
	if len(args) > 3 {
		proxyURL = args[3]
	}

	e.Author = &discordgo.MessageEmbedAuthor{
		Name:         name,
		IconURL:      iconURL,
		URL:          URL,
		ProxyIconURL: proxyURL,
	}

	return e
}

//SetURL ...
func (e *Embed) SetURL(URL string) *Embed {
	e.URL = URL
	return e
}

//SetColor ...
func (e *Embed) SetColor(clr int) *Embed {
	e.Color = clr
	return e
}

// InlineAllFields sets all fields in the embed to be inline
func (e *Embed) InlineAllFields() *Embed {
	for _, v := range e.Fields {
		v.Inline = true
	}
	return e
}

// Truncate truncates any embed value over the character limit.
func (e *Embed) Truncate() *Embed {
	e.TruncateDescription()
	e.TruncateFields()
	e.TruncateFooter()
	e.TruncateTitle()
	return e
}

// TruncateFields truncates fields that are too long
func (e *Embed) TruncateFields() *Embed {
	if len(e.Fields) > 25 {
		e.Fields = e.Fields[:EmbedLimitField]
	}

	for _, v := range e.Fields {

		if len(v.Name) > EmbedLimitFieldName {
			v.Name = v.Name[:EmbedLimitFieldName]
		}

		if len(v.Value) > EmbedLimitFieldValue {
			v.Value = v.Value[:EmbedLimitFieldValue]
		}

	}
	return e
}

// TruncateDescription ...
func (e *Embed) TruncateDescription() *Embed {
	if len(e.Description) > EmbedLimitDescription {
		e.Description = e.Description[:EmbedLimitDescription]
	}
	return e
}

// TruncateTitle ...
func (e *Embed) TruncateTitle() *Embed {
	if len(e.Title) > EmbedLimitTitle {
		e.Title = e.Title[:EmbedLimitTitle]
	}
	return e
}

// TruncateFooter ...
func (e *Embed) TruncateFooter() *Embed {
	if e.Footer != nil && len(e.Footer.Text) > EmbedLimitFooter {
		e.Footer.Text = e.Footer.Text[:EmbedLimitFooter]
	}
	return e
}


text:
using namespace gpdxl;
using namespace gpmd;

//---------------------------------------------------------------------------
//	@function:
//		CDXLOperator::CDXLOperator
//
//	@doc:
//		Constructor
//
//---------------------------------------------------------------------------
CDXLOperator::CDXLOperator
	(
	IMemoryPool *pmp
	)
	:
	m_pmp(pmp)
{
}

//---------------------------------------------------------------------------
//	@function:
//		CDXLOperator::~CDXLOperator
//
//	@doc:
//		Dtor
//
//---------------------------------------------------------------------------
CDXLOperator::~CDXLOperator()
{
}

//---------------------------------------------------------------------------
//	@function:
//		CDXLOperator::PstrJoinTypeName
//
//	@doc:
//		Join type name
//
//---------------------------------------------------------------------------
const CWStringConst *
CDXLOperator::PstrJoinTypeName
	(
	EdxlJoinType edxljt
	)
{
	GPOS_ASSERT(EdxljtSentinel > edxljt);

	switch (edxljt)
	{
		case EdxljtInner:
			return CDXLTokens::PstrToken(EdxltokenJoinInner);

		case EdxljtLeft:
			return CDXLTokens::PstrToken(EdxltokenJoinLeft);

		case EdxljtFull:
			return CDXLTokens::PstrToken(EdxltokenJoinFull);

		case EdxljtRight:
			return CDXLTokens::PstrToken(EdxltokenJoinRight);

		case EdxljtIn:
			return CDXLTokens::PstrToken(EdxltokenJoinIn);

		case EdxljtLeftAntiSemijoin:
			return CDXLTokens::PstrToken(EdxltokenJoinLeftAntiSemiJoin);

		case EdxljtLeftAntiSemijoinNotIn:
			return CDXLTokens::PstrToken(EdxltokenJoinLeftAntiSemiJoinNotIn);

		default:
			return CDXLTokens::PstrToken(EdxltokenUnknown);
	}
}

//---------------------------------------------------------------------------
//	@function:
//		CDXLOperator::PstrIndexScanDirection
//
//	@doc:
//		Return the index scan direction name
//
//---------------------------------------------------------------------------
const CWStringConst *
CDXLOperator::PstrIndexScanDirection
	(
	EdxlIndexScanDirection edxlisd
	)
{
	switch (edxlisd)
	{
		case EdxlisdBackward:
			return CDXLTokens::PstrToken(EdxltokenIndexScanDirectionBackward);

		case EdxlisdForward:
			return CDXLTokens::PstrToken(EdxltokenIndexScanDirectionForward);

		case EdxlisdNoMovement:
			return CDXLTokens::PstrToken(EdxltokenIndexScanDirectionNoMovement);

		default:
			GPOS_ASSERT(!"Unrecognized index scan direction");
			return CDXLTokens::PstrToken(EdxltokenUnknown);
	}
}

// EOF


text:
package org.squbs.httpclient.pipeline.impl

import akka.actor.ActorRefFactory
import org.squbs.pipeline.ProxyResponse._
import org.squbs.pipeline.{Handler, RequestContext}
import spray.http.HttpHeader

import scala.concurrent.Future

class ResponseAddHeaderHandler(httpHeader: HttpHeader) extends Handler {
	override def process(reqCtx: RequestContext)(implicit context: ActorRefFactory): Future[RequestContext] = {
		import context.dispatcher
		Future {
			reqCtx.copy(response = reqCtx.response + httpHeader)
		}
	}
}

class ResponseRemoveHeaderHandler(httpHeader: HttpHeader) extends Handler {
	override def process(reqCtx: RequestContext)(implicit context: ActorRefFactory): Future[RequestContext] = {
		import context.dispatcher
		Future {
			reqCtx.copy(response = reqCtx.response - httpHeader)
		}
	}
}

class ResponseUpdateHeaderHandler(httpHeader: HttpHeader) extends Handler {
	override def process(reqCtx: RequestContext)(implicit context: ActorRefFactory): Future[RequestContext] = {
		import context.dispatcher
		Future {
			reqCtx.copy(response = reqCtx.response - httpHeader + httpHeader)
		}
	}
}


text:
<?php
require_once(dirname(__FILE__).'/../TokenParser.php');
require_once(dirname(__FILE__).'/../Token.php');
require_once(dirname(__FILE__).'/../Node/For.php');
require_once(dirname(__FILE__).'/../Node/Expression/AssignName.php');
require_once(dirname(__FILE__).'/../Node/Expression/Name.php');

class SQLShade_TokenParser_For extends SQLShade_TokenParser
{
    public function parse(SQLShade_Token $token)
    {
        $lineno = $token->getLine();

        $alias = $this->parser->getExpressionParser()->parsePrimaryExpression(true);

        $this->parser->getStream()->expect(SQLShade_Token::NAME_TYPE, 'in');

        $sequence = $this->parser->getExpressionParser()->parsePrimaryExpression();
        $this->parser->getStream()->expect(SQLShade_Token::BLOCK_END_TYPE);
        $compound = $this->parser->subparse(array($this, 'decideForEnd'), true);
        $this->parser->getStream()->expect(SQLShade_Token::BLOCK_END_TYPE);

        return new SQLShade_Node_For($alias, $sequence, $compound, $lineno, null);
    }

    public function decideForEnd($token)
    {
        return $token->test($this->getEndTag());
    }

    public function getTag()
    {
        return 'for';
    }

    public function getEndTag()
    {
        return 'endfor';
    }
}


text:
using System;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;

using Object = UnityEngine.Object;

namespace AGXUnityEditor.IO
{
  public static partial class Utils
  {
    private const string m_refDirectory = "AGXUnity";
    private const string m_refScript = "RigidBody.cs";
    private static string m_relDataPathDir = string.Empty;

    /// <summary>
    /// Absolute Unity project directory without trailing /, i.e., add '/Assets/Foo' for
    /// directory Foo in the project default assets folder.
    /// </summary>
    public static string ProjectDirectory
    {
      get
      {
        return Application.dataPath.Remove( Application.dataPath.LastIndexOf( "/Assets" ),
                                            "/Assets".Length );
      }
    }

    /// <summary>
    /// Directory of AGXUnity source code, i.e, package directory + /AGXUnity.
    /// </summary>
    public static string AGXUnitySourceDirectory
    {
      get
      {
        return AGXUnityPackageDirectory + "/AGXUnity";
      }
    }

    /// <summary>
    /// Absolute directory of AGXUnity source code, i.e, full package directory + /AGXUnity.
    /// </summary>
    public static string AGXUnitySourceDirectoryFull
    {
      get { return ProjectDirectory + '/' + AGXUnitySourceDirectory; }
    }

    /// <summary>
    /// AGXUnity resources directory, i.e, package directory + /Resources.
    /// </summary>
    public static string AGXUnityResourceDirectory
    {
      get { return AGXUnityPackageDirectory + "/Resources"; }
    }

    /// <summary>
    /// Absolute directory of AGXUnity resources, i.e., package directory full + /Resources.
    /// </summary>
    public static string AGXUnityResourceDirectoryFull
    {
      get { return ProjectDirectory + '/' + AGXUnityResourceDirectory; }
    }

    /// <summary>
    /// Native plugin directory, i.e., package directory + /Plugins/x86_64.
    /// </summary>
    public static string AGXUnityPluginDirectory
    {
      get { return AGXUnityPackageDirectory + "/Plugins/x86_64"; }
    }

    /// <summary>
    /// Native plugin directory, i.e., package directory full + /Plugins/x86_64.
    /// </summary>
    public static string AGXUnityPluginDirectoryFull
    {
      get { return ProjectDirectory + '/' + AGXUnityPluginDirectory; }
    }

    /// <summary>
    /// AGXUnity package editor directory, i.e., package directory + /Editor.
    /// </summary>
    public static string AGXUnityEditorDirectory
    {
      get { return AGXUnityPackageDirectory + "/Editor"; }
    }

    /// <summary>
    /// Absolute directory of AGXUnity editor, i.e. package directory full + /Editor.
    /// </summary>
    public static string AGXUnityEditorDirectoryFull
    {
      get { return ProjectDirectory + '/' + AGXUnityEditorDirectory; }
    }

    /// <summary>
    /// Directory of AGXUnityEditor source code, i.e, package directory + /Editor/AGXUnityEditor.
    /// </summary>
    public static string AGXUnityEditorSourceDirectory
    {
      get { return AGXUnityPackageDirectory + "/Editor/AGXUnityEditor"; }
    }

    /// <summary>
    /// Absolute directory of AGXUnityEditor source code, i.e, full package directory + /Editor/AGXUnityEditor.
    /// </summary>
    public static string AGXUnityEditorSourceDirectoryFull
    {
      get { return ProjectDirectory + '/' + AGXUnityEditorSourceDirectory; }
    }

    /// <summary>
    /// AGXUnity package directory relative Unity project, e.g., Assets/Foo if AGXUnity source
    /// is located in Assets/Foo/AGXUnity, AGXUnityEditor source in Assets/Foo/Editor/AGXUnityEditor
    /// and resources in Assets/Foo/Resources. 'Foo' is by default 'AGXUnity'.
    /// </summary>
    public static string AGXUnityPackageDirectory
    {
      get
      {
        var refScriptFullPath = Application.dataPath + '/' + m_relDataPathDir + '/' + m_refDirectory + '/' + m_refScript;
        if ( m_relDataPathDir != "" && File.Exists( refScriptFullPath ) )
          return "Assets/" + m_relDataPathDir;

        var results = Directory.GetFiles( Application.dataPath, m_refScript, SearchOption.AllDirectories );
        foreach ( var result in results ) {
          var file = new FileInfo( result );
          if ( file.Directory.Name == "AGXUnity" ) {
            m_relDataPathDir = MakeRelative( file.Directory.Parent.FullName, Application.dataPath ).Remove( 0, "Assets/".Length );
            break;
          }
        }

        return "Assets/" + m_relDataPathDir;
      }
    }

    /// <summary>
    /// Full path to the AGXUnity install directory.
    /// </summary>
    public static string AGXUnityPackageDirectoryFull
    {
      get { return ProjectDirectory + '/' + AGXUnityPackageDirectory; }
    }

    /// <summary>
    /// True if AGX Dynamics is assumed to be installed in the project,
    /// i.e., Unity hasn't been started with AGX Dynamics in path.
    /// </summary>
    public static bool AGXDynamicsInstalledInProject
    {
      get
      {
        var di = new DirectoryInfo( AGXUnityPluginDirectoryFull );
        if ( !di.Exists )
          throw new AGXUnity.Exception( "Unable to find AGXUnity plugins directory: " + di.FullName );

        var dllsToFind = new string[] { "agxCore.dll", "agxPhysics.dll", "agxSabre.dll" };
        int numFound = 0;
        foreach ( var file in di.EnumerateFiles( "*.dll" ) )
          if ( Array.FindIndex( dllsToFind, name => name == file.Name ) >= 0 )
            ++numFound;
        return numFound == dllsToFind.Length;
      }
    }

    /// <summary>
    /// Verifies so that each property (returning a directory path) above
    /// with property name containing AGXUnity and Directory is returning
    /// a path to a valid folder.  If the folder doesn't exist, a warning
    /// is issued.
    /// </summary>
    public static void VerifyDirectories()
    {
      Predicate<string> isRelDirectory = name => name.Contains( "AGXUnity" ) &&
                                                 name.Contains( "Directory" ) &&
                                                !name.Contains( "Full" );
      var directories = ( from propertyInfo
                          in typeof( Utils ).GetProperties( BindingFlags.Public | BindingFlags.Static )
                          where isRelDirectory( propertyInfo.Name )
                          select (string)propertyInfo.GetGetMethod().Invoke( null, new object[] { } ) ).ToArray();
      foreach ( var dir in directories ) {
        if ( !AssetDatabase.IsValidFolder( dir ) )
          Debug.LogWarning( "Missing AGXUnity directory: " + dir );
      }
    }

    /// <summary>
    /// Makes relative path given complete path.
    /// </summary>
    /// <param name="complete">Complete path.</param>
    /// <param name="root">New root directory.</param>
    /// <returns>Path with <paramref name="root"/> as root.</returns>
    public static string MakeRelative( string complete, string root )
    {
      var completeUri = new Uri( complete );
      var rootUri = new Uri( root );
      var relUri = rootUri.MakeRelativeUri( completeUri );
      return Uri.UnescapeDataString( relUri.ToString() );
    }

    /// <summary>
    /// Finds assets of given type <typeparamref name="T"/> inside the given
    /// <paramref name="directory"/>.
    /// </summary>
    /// <typeparam name="T">Asset type.</typeparam>
    /// <param name="directory">Directory relative to the projects folder.</param>
    /// <returns>Array of assets of given type in the given directory.</returns>
    public static T[] FindAssetsOfType<T>( string directory )
      where T : Object
    {
      return ( from obj in FindAssetsOfType( directory, typeof( T ) )
               where obj is T
               select obj as T ).ToArray();
    }

    /// <summary>
    /// Finds assets of given type <paramref name="type"/> inside the given
    /// <paramref name="directory"/>.
    /// </summary>
    /// <typeparam name="T">Asset type.</typeparam>
    /// <param name="directory">Directory relative to the projects folder.</param>
    /// <param name="type">Asset type.</param>
    /// <returns>Array of assets of given type in the given directory.</returns>
    public static Object[] FindAssetsOfType( string directory, Type type )
    {
      // FindAssets will return same GUID for all grouped assets (AddObjectToAsset), so
      // if we have 17 ContactMaterial assets in a group FindAsset will return an array
      // of 17 where all entries are identical.
      var typeName = string.Empty;
      if ( type.Namespace != null && type.Namespace.StartsWith( "UnityEngine" ) )
        typeName = type.Name;
      else
        typeName = type.FullName;
      var guids = string.IsNullOrEmpty( directory ) ?
                    AssetDatabase.FindAssets( "t:" + typeName ).Distinct() :
                    AssetDatabase.FindAssets( "t:" + typeName, new string[] { directory } ).Distinct();
      return ( from guid
               in guids
               from obj
               in AssetDatabase.LoadAllAssetsAtPath( AssetDatabase.GUIDToAssetPath( guid ) )
               select obj ).ToArray();
    }

    /// <summary>
    /// Finds selected assets with extension <paramref name="fileExtension"/>.
    /// </summary>
    /// <param name="fileExtension">File extension, e.g., ".txt"."</param>
    /// <param name="warnAboutDifferentExtensions">True to warn about assets that doesn't match <paramref name="fileExtension"/>.</param>
    /// <returns>Array of asset paths to selected assets of given <paramref name="fileExtension"/> extension.</returns>
    public static string[] GetSelectedFiles( string fileExtension,
                                             bool warnAboutDifferentExtensions = false )
    {
      if ( string.IsNullOrEmpty( fileExtension ) )
        return new string[] { };
      if ( fileExtension[ 0 ] != '.' )
        fileExtension = '.' + fileExtension;

      var filesWithCorrectExtension = new List<string>();
      var filesWithWrongExtension = new List<string>();
      foreach ( var guid in Selection.assetGUIDs ) {
        var assetPath = AssetDatabase.GUIDToAssetPath( guid );
        if ( string.IsNullOrEmpty( assetPath ) )
          continue;
        if ( Path.GetExtension( assetPath ).ToLower() == fileExtension.ToLower() )
          filesWithCorrectExtension.Add( assetPath );
        else if ( warnAboutDifferentExtensions )
          filesWithWrongExtension.Add( assetPath );
      }

      foreach ( var fileWithWrongExtension in filesWithWrongExtension )
        Debug.LogWarning( $"File extension of {AGXUnity.Utils.GUI.AddColorTag( fileWithWrongExtension, Color.red )} " +
                          $"doesn't match the given {fileExtension} extension." );

      return filesWithCorrectExtension.ToArray();
    }
  }
}


text:
module Azure::ServiceFabric::V6_5_0_36
  module Models
    #
    # Describes an update for a stateless service.
    #
    class StatelessServiceUpdateDescription < ServiceUpdateDescription

      include MsRestAzure

      def initialize
        @ServiceKind = "Stateless"
      end

      attr_accessor :ServiceKind

      # @return [Integer] The instance count.
      attr_accessor :instance_count

      #
      # Mapper for StatelessServiceUpdateDescription class as Ruby Hash.
      # This will be used for serialization/deserialization.
      #
      def self.mapper()
        {
          client_side_validation: true,
          required: false,
          serialized_name: 'Stateless',
          type: {
            name: 'Composite',
            class_name: 'StatelessServiceUpdateDescription',
            model_properties: {
              flags: {
                client_side_validation: true,
                required: false,
                serialized_name: 'Flags',
                type: {
                  name: 'String'
                }
              },
              placement_constraints: {
                client_side_validation: true,
                required: false,
                serialized_name: 'PlacementConstraints',
                type: {
                  name: 'String'
                }
              },
              correlation_scheme: {
                client_side_validation: true,
                required: false,
                serialized_name: 'CorrelationScheme',
                type: {
                  name: 'Sequence',
                  element: {
                      client_side_validation: true,
                      required: false,
                      serialized_name: 'ServiceCorrelationDescriptionElementType',
                      type: {
                        name: 'Composite',
                        class_name: 'ServiceCorrelationDescription'
                      }
                  }
                }
              },
              load_metrics: {
                client_side_validation: true,
                required: false,
                serialized_name: 'LoadMetrics',
                type: {
                  name: 'Sequence',
                  element: {
                      client_side_validation: true,
                      required: false,
                      serialized_name: 'ServiceLoadMetricDescriptionElementType',
                      type: {
                        name: 'Composite',
                        class_name: 'ServiceLoadMetricDescription'
                      }
                  }
                }
              },
              service_placement_policies: {
                client_side_validation: true,
                required: false,
                serialized_name: 'ServicePlacementPolicies',
                type: {
                  name: 'Sequence',
                  element: {
                      client_side_validation: true,
                      required: false,
                      serialized_name: 'ServicePlacementPolicyDescriptionElementType',
                      type: {
                        name: 'Composite',
                        polymorphic_discriminator: 'Type',
                        uber_parent: 'ServicePlacementPolicyDescription',
                        class_name: 'ServicePlacementPolicyDescription'
                      }
                  }
                }
              },
              default_move_cost: {
                client_side_validation: true,
                required: false,
                serialized_name: 'DefaultMoveCost',
                type: {
                  name: 'String'
                }
              },
              scaling_policies: {
                client_side_validation: true,
                required: false,
                serialized_name: 'ScalingPolicies',
                type: {
                  name: 'Sequence',
                  element: {
                      client_side_validation: true,
                      required: false,
                      serialized_name: 'ScalingPolicyDescriptionElementType',
                      type: {
                        name: 'Composite',
                        class_name: 'ScalingPolicyDescription'
                      }
                  }
                }
              },
              ServiceKind: {
                client_side_validation: true,
                required: true,
                serialized_name: 'ServiceKind',
                type: {
                  name: 'String'
                }
              },
              instance_count: {
                client_side_validation: true,
                required: false,
                serialized_name: 'InstanceCount',
                constraints: {
                  InclusiveMinimum: -1
                },
                type: {
                  name: 'Number'
                }
              }
            }
          }
        }
      end
    end
  end
end